Programmation JavaScript

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.10/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.10/ http://www.mediawiki.org/xml/export-0.10.xsd" version="0.10" xml:lang="fr">
  <siteinfo>
    <sitename>Wikilivres</sitename>
    <dbname>frwikibooks</dbname>
    <base>https://fr.wikibooks.org/wiki/Accueil</base>
    <generator>MediaWiki 1.39.0-wmf.26</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Média</namespace>
      <namespace key="-1" case="first-letter">Spécial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Discussion</namespace>
      <namespace key="2" case="first-letter">Utilisateur</namespace>
      <namespace key="3" case="first-letter">Discussion utilisateur</namespace>
      <namespace key="4" case="first-letter">Wikilivres</namespace>
      <namespace key="5" case="first-letter">Discussion Wikilivres</namespace>
      <namespace key="6" case="first-letter">Fichier</namespace>
      <namespace key="7" case="first-letter">Discussion fichier</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">Discussion MediaWiki</namespace>
      <namespace key="10" case="first-letter">Modèle</namespace>
      <namespace key="11" case="first-letter">Discussion modèle</namespace>
      <namespace key="12" case="first-letter">Aide</namespace>
      <namespace key="13" case="first-letter">Discussion aide</namespace>
      <namespace key="14" case="first-letter">Catégorie</namespace>
      <namespace key="15" case="first-letter">Discussion catégorie</namespace>
      <namespace key="100" case="first-letter">Transwiki</namespace>
      <namespace key="101" case="first-letter">Discussion Transwiki</namespace>
      <namespace key="102" case="first-letter">Wikijunior</namespace>
      <namespace key="103" case="first-letter">Discussion Wikijunior</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Module</namespace>
      <namespace key="829" case="first-letter">Discussion module</namespace>
      <namespace key="2300" case="first-letter">Gadget</namespace>
      <namespace key="2301" case="first-letter">Discussion gadget</namespace>
      <namespace key="2302" case="case-sensitive">Définition de gadget</namespace>
      <namespace key="2303" case="case-sensitive">Discussion définition de gadget</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Programmation JavaScript</title>
    <ns>0</ns>
    <id>713</id>
    <revision>
      <id>684246</id>
      <parentid>683414</parentid>
      <timestamp>2022-08-27T12:57:48Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1248" xml:space="preserve">{{Page de garde|image=Unofficial JavaScript logo 2.svg|description=

''un livre appartenant à la série [[Programmation]]&lt;br/&gt;de l'[[Accueil/Informatique|étagère Informatique]] de [[Accueil|Wikilivres]]''.

JavaScript est un langage de programmation utilisé initialement par les navigateurs web, puis sur les serveurs web et pour des applications graphiques. Il partage avec Java une syntaxe inspirée du langage C, mais leurs similitudes s'arrêtent là.
Aujourd'hui il est défini par le standard ECMA 262, connu aussi sous l'appellation ECMAScript (ES).

Les pages web l'utilisent pour interagir avec l'utilisateur et le document [[Le langage HTML|HTML]] et ses feuilles de style [[Le langage CSS|CSS]].

|avancement=Terminé
|cdu=
* {{CDU item|6/68/681|681.3/681.3.0}}
|versions=
{{Version imprimable}}
{{Version PDF}}
}}

&lt;div style=&quot;float:right; width:300px;&quot;&gt;
{{Lecture nécessaire|[[Le langage HTML|HTML]]}}
{{Lecture nécessaire|[[Le langage CSS]]}}
{{moteur}}
{{:Programmation JavaScript/Informations}}
{{Autres projets
|w=JavaScript
|wikt=JavaScript
|v=JavaScript}}
&lt;/div&gt;
{{:Programmation JavaScript/Sommaire}}

[[Catégorie:JavaScript]]
[[Catégorie:Livres en cours de rédaction]]
[[Catégorie:Programmation JavaScript (livre)|!]]</text>
      <sha1>crbxsrvf8v4ijimhbpr1xe61p7vutfe</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation SQL</title>
    <ns>0</ns>
    <id>791</id>
    <revision>
      <id>684245</id>
      <parentid>683254</parentid>
      <timestamp>2022-08-27T12:57:44Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="884" xml:space="preserve">{{Icône version compilée}}
{{Page de garde|image=Sql database shortcut icon.png|description=

''Un livre appartenant à la série [[Programmation]]&lt;br/&gt;de l'[[Accueil/Informatique|étagère Informatique]] de [[Accueil|Wikilivres]]''.

|avancement=Bon début
|cdu=
* {{CDU item|6/68/681|681.3/681.3.0}}
|versions=
{{version imprimable}}
{{version PDF}}
}}

{{moteur}}
{{Autres projets
|wikt=SQL
|w=Structured Query Language
|v=Structured Query Language
}}
{{:Programmation SQL/Sommaire}}
&lt;noinclude&gt;

== Voir aussi ==
* [[Les bases de données]]

Ce livre étant pour le moment incomplet, si vous lisez l'anglais, un complément utile est la page de Wikipedia [[w:en:Structured Query Language|SQL]], où les mot-clés de SQL sont des hyperliens vers d'autres pages de Wikipedia en langue anglaise. Lesdites pages comportent des exemples.

{{AutoCat}}
&lt;/noinclude&gt;

[[Catégorie:SQL]]</text>
      <sha1>2tphud4d515tq9e2rupe5fl8lvkslj5</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation C-C++/Notation des valeurs</title>
    <ns>0</ns>
    <id>2353</id>
    <revision>
      <id>684280</id>
      <parentid>559368</parentid>
      <timestamp>2022-08-27T18:20:39Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4441" xml:space="preserve">{{Programmation C C plus plus Première approche}}
== Notation des valeurs ==

Les entiers se notent de la manière suivante :
* base 10 (décimale) : avec les chiffres de '0' à '9', et les signes '+' (facultatif) et '-'.

=== Exemple - Notation des entiers en base 10 ===
&lt;pre&gt;
12354, -2564
&lt;/pre&gt;
* base 16 (hexadécimale) : avec les chiffres '0' à '9' et 'A' à 'F' ou a à f (A=a=10, B=b=11, ... F=f=15). Les entiers notés en hexadécimal devront toujours être précédés de « 0x » (qui indique la base). On ne peut pas utiliser le signe '-' avec les nombres hexadécimaux.

=== Exemple - Notation des entiers en base 16 ===
&lt;pre&gt;
0x1AE
&lt;/pre&gt;
* base 8 (octale) : avec les chiffres de '0' à '7'. Les nombres octaux doivent être précédés d'un 0 (qui indique la base). Le signe '-' ne peut pas être utilisé.

=== Exemple - Notation des entiers en base 8 ===
&lt;pre&gt;
01, 0154
&lt;/pre&gt;

Les flottants (pseudo réels) se notent de la manière suivante :

[signe] chiffres [.[chiffres]][e|E [signe] exposant][f]

où signe indique le signe. On emploie les signes '+' (facultatif) et '-' aussi bien pour la mantisse que pour l'exposant. 'e' ou 'E' permet de donner l'exposant du nombre flottant. L'exposant est facultatif. Si on ne donne pas d'exposant, on doit donner des chiffres derrière la virgule avec un point et ces chiffres. Le suffixe 'f' permet de préciser si le nombre est de type float ou non (auquel cas il s'agit d'un double).

Les chiffres après la virgule sont facultatifs, mais pas le point. Si on ne met ni le point, ni la mantisse, le nombre est un entier décimal.

=== Exemple - Notation des réels ===
&lt;pre&gt;
-123.56f, 12e-12, 2
&lt;/pre&gt;
« 2 » est entier, « 2.f » est réel.

Les caractères se notent entre guillemets simples :
&lt;pre&gt;
'A', 'c', '('
&lt;/pre&gt;
On peut donner un caractère non accessible au clavier en donnant son code en octal, précédé du caractère '\'. Par exemple, le caractère 'A' peut aussi être noté '\101'. Remarquez que cette notation est semblable à la notation des nombres entiers en octal, et que le '0' initial est simplement remplacé par un '\'. Il est aussi possible de noter les caractères avec leur code en hexadécimal, à l'aide de la notation « \xNN », où NN est le code hexadécimal du caractère. Enfin, il existe des séquences d'échappement particulières qui permettent de coder certains caractères spéciaux plus facilement. Les principales séquences d'échappement sont les suivantes :
{|
 | '\a' || Bip sonore
 |-
 | '\b' || Backspace
 |-
 | '\f' || Début de page suivante
 |-
 | '\r' || Retour à la ligne (sans saut de ligne)
 |-
 | '\n' || Passage à la ligne
 |-
 | '\t' || Tabulation
 |-
 | '\v' || Tabulation verticale
 |}
D'autres séquences d'échappement sont disponibles, afin de pouvoir représenter les caractères ayant une signification particulière en C :
{|
 | '\\' || Le caractère \
 |-
 | '\&quot;' || Le caractère &quot;
 |-
 | &lt;nowiki&gt;'\''&lt;/nowiki&gt;	|| Le caractère '
 |}

Bien qu'il n'existe pas à proprement parler de chaînes de caractères en C/C++, il est possible de définir des tableaux de caractères constants utilisables en tant que chaînes de caractères en donnant leur contenu entre doubles guillemets :
&lt;pre&gt;
&quot;Exemple de chaîne de caractères...&quot;
&lt;/pre&gt;
Les caractères spéciaux peuvent être utilisés directement dans les chaînes de caractères constantes :
&lt;pre&gt;
&quot;Ceci est un saut de ligne :\nCeci est à la ligne suivante.&quot;
&lt;/pre&gt;
Si une chaîne de caractères constante est trop longue pour tenir sur une seule ligne, on peut concaténer plusieurs chaînes en les juxtaposant :
&lt;pre&gt;
&quot;Ceci est la première chaîne &quot; &quot;ceci est la deuxième.&quot;
&lt;/pre&gt;
produit la chaîne de caractères complète suivante :
&lt;pre&gt;
&quot;Ceci est la première chaîne ceci est la deuxième.&quot;
&lt;/pre&gt;
Note : Attention : il ne faut pas mettre de caractère nul dans une chaîne de caractères. Ce caractère est en effet le caractère de terminaison de toute chaîne de caractères. 

Enfin, les versions longues des différents types cités précédemment (wchar_t, long int et long double) peuvent être notées en faisant précéder ou suivre la valeur de la lettre 'L'. Cette lettre doit précéder la valeur dans le cas des caractères et des chaînes de caractères et la suivre quand il s'agit des entiers et des flottants. Par exemple :
&lt;pre&gt;
L&quot;Ceci est une chaîne de wchar_t.&quot;
2.3e5L
&lt;/pre&gt;

[[Catégorie:Programmation C-C++ (livre)]]</text>
      <sha1>a23i1un377h03cp1t5usarl8a6qwp19</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation GTK2 en Pascal</title>
    <ns>0</ns>
    <id>2419</id>
    <revision>
      <id>684230</id>
      <parentid>549769</parentid>
      <timestamp>2022-08-27T12:48:29Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <comment>{{version imprimable}}</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5491" xml:space="preserve">{{version imprimable}}

=== Sommaire de ce « livre » ===

* [[Programmation GTK2 en Pascal/Introduction|Introduction]]
* Pré-requis
** [[Programmation GTK2 en Pascal/Logiciels nécessaires|Logiciels nécessaires]]
** [[Programmation GTK2 en Pascal/Installation sous Linux|Installation sous Linux]]
** [[Programmation GTK2 en Pascal/Installation sous Windows|Installation sous Windows]]
** [[Programmation GTK2 en Pascal/Installation sous Mac/OS|Installation sous Mac/OS]]
* [[Programmation GTK2 en Pascal/Une application minimale|Une application minimale]]
* Les bases
** [[Programmation GTK2 en Pascal/La notion d'objet|La notion d'objet]]
** [[Programmation GTK2 en Pascal/La gestion des évènements|La gestion des évènements]]
** [[Programmation GTK2 en Pascal/Le placement des contrôles|Le placement des contrôles]]
* Les contrôles (''widgets'') Gtk
** [[Programmation GTK2 en Pascal/Les fenêtres|Les fenêtres]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkWindow|GtkWindow]] ~ [[Programmation GTK2 en Pascal/GtkDialog|GtkDialog]] ~ [[Programmation GTK2 en Pascal/GtkMessageDialog|GtkMessageDialog]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les conteneurs|Les conteneurs]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkContainer|GtkContainer]] ~ [[Programmation GTK2 en Pascal/GtkBox|GtkBox]] ~ [[Programmation GTK2 en Pascal/GtkBin|GtkBin]] ~ [[Programmation GTK2 en Pascal/GtkHBox|GtkHBox]] ~ [[Programmation GTK2 en Pascal/GtkVBox|GtkVBox]] ~ [[Programmation GTK2 en Pascal/GtkTable|GtkTable]] ~ [[Programmation GTK2 en Pascal/GtkNotebook|GtkNotebook]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les visuels|Les visuels]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkLabel|GtkLabel]] ~ [[Programmation GTK2 en Pascal/GtkImage|GtkImage]] ~ [[Programmation GTK2 en Pascal/GtkStatusBar|GtkStatusBar]] ~ [[Programmation GTK2 en Pascal/GtkProgressBar|GtkProgressBar]] ~ [[Programmation GTK2 en Pascal/GtkDrawingArea|GtkDrawingArea]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les boutons|Les boutons]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkButton|GtkButton]] ~ [[Programmation GTK2 en Pascal/GtkToggleButton|GtkToggleButton]] ~ [[Programmation GTK2 en Pascal/GtkCheckButton|GtkCheckButton]] ~ [[Programmation GTK2 en Pascal/GtkRadioButton|GtkRadioButton]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/La saisie de données|La saisie de données]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkEntry|GtkEntry]] ~ [[Programmation GTK2 en Pascal/GtkHScale|GtkHScale]] ~ [[Programmation GTK2 en Pascal/GtkVScale|GtkVScale]] ~ [[Programmation GTK2 en Pascal/GtkSpinButton|GtkSpinButton]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les listes déroulantes|Les listes déroulantes]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkComboBox|GtkComboBox]] ~ [[Programmation GTK2 en Pascal/GtkComboBoxEntry|GtkComboBoxEntry]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les menus|Les menus]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkMenu|GtkMenu]] ~ [[Programmation GTK2 en Pascal/GtkMenuBar|GtkMenuBar]] ~ [[Programmation GTK2 en Pascal/GtkMenuItem|GtkMenuItem]] ~ [[Programmation GTK2 en Pascal/GtkMenuShell|GtkMenuShell]] ~ [[Programmation GTK2 en Pascal/GtkImageMenuItem|GtkImageMenuItem]] ~ [[Programmation GTK2 en Pascal/GtkRadioMenuItem|GtkRadioMenuItem]] ~ [[Programmation GTK2 en Pascal/GtkCheckMenuItem|GtkCheckMenuItem]] ~ [[Programmation GTK2 en Pascal/GtkSeparatorMenuItem|GtkSeparatorMenuItem]] ~ [[Programmation GTK2 en Pascal/GtkTearoffMenuItem|GtkTearoffMenuItem]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les décorations|Les décorations]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkFrame|GtkFrame]] ~ [[Programmation GTK2 en Pascal/GtkHSeparator|GtkHSeparator]] ~ [[Programmation GTK2 en Pascal/GtkVSeparator|GtkVSeparator]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/La barre d'outils|La barre d'outils]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkToolbar|GtkToolbar]] ~ [[Programmation GTK2 en Pascal/GtkToolItem|GtkToolItem]] ~ [[Programmation GTK2 en Pascal/GtkToolButton|GtkToolButton]] ~ [[Programmation GTK2 en Pascal/GtkMenuToolButton|GtkMenuToolButton]] ~ [[Programmation GTK2 en Pascal/GtkToggleToolButton|GtkToggleToolButton]] ~ [[Programmation GTK2 en Pascal/GtkRadioToolButton|GtkRadioToolButton]] ~ [[Programmation GTK2 en Pascal/GtkSeparatorToolItem|GtkSeparatorToolItem]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les sélections|Les sélections]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkFileSelection|GtkFileSelection]] ~ [[Programmation GTK2 en Pascal/GtkColorSelectionDialog|GtkColorSelectionDialog]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les zones de texte|Les zones de texte]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkTextView|GtkTextView]] ~ [[Programmation GTK2 en Pascal/GtkTextBuffer|GtkTextBuffer]]&lt;/small&gt;
** [[Programmation GTK2 en Pascal/Les listes et arbres|Les listes et arbres]]&lt;br /&gt;&lt;small&gt;[[Programmation GTK2 en Pascal/GtkTreeView|GtkTreeView]] ~ [[Programmation GTK2 en Pascal/GtkTreeModel|GtkTreeModel]]&lt;/small&gt;
* La Glib
** [[Programmation GTK2 en Pascal/Objets de la glib|Objets de la glib]]
** [[Programmation GTK2 en Pascal/Fonctions de la glib|Fonctions de la glib]]
* [[Programmation GTK2 en Pascal/Dessiner avec le Gdk|Dessiner avec le Gdk]]
* [[Programmation GTK2 en Pascal/Conclusion|Conclusion]]
* [[Programmation GTK2 en Pascal/Bibliographie|Bibliographie]]

{{Programmation}}

[[Catégorie:Pascal (langage)|GTK]]
[[Catégorie:GTK|Pascal]]
[[Catégorie:Programmation GTK2 en Pascal (livre)|*]]</text>
      <sha1>hb41cpwbr5munqc3v6s2xs1ca4flaxk</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation GTK2 en Pascal/Introduction</title>
    <ns>0</ns>
    <id>2421</id>
    <revision>
      <id>684234</id>
      <parentid>328824</parentid>
      <timestamp>2022-08-27T12:50:45Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1044" xml:space="preserve">&lt;noinclude&gt;{{Programmation GTK2 en Pascal}}&lt;/noinclude&gt;

'''GTK+''' (The Gimp Tool Kit) est un ensemble de bibliothèques (au sens informatique du terme, c'est-à-dire un ensemble de fonctions) développé originellement pour les besoins du logiciel de traitement d'images The Gimp (GNU Image Manipulation Program) et utilisé également pour le développement de l'environnement de bureau GNOME.

GTK+ peut-être utilisé pour créer des programmes avec interfaces graphiques facilement.

GTK+ est libre (licence GNU LGPL) et multiplateforme.

Le plan de ce « livre » est calqué sur le site wiki [http://www.gtk-fr.org/ GtkFr - Cours Gtk+-2] qui concerne la programmation de GTK+ version 2 mais en langage C. Ce site et son ancêtre [http://www.gtk-fr.org/old/] sont sous licence GFDL.

Ce « livre » se veut donc l'équivalent, un manuel de référence pour la programmation GTK+ version 2 en langage Pascal. Une bonne connaissance du Pascal est nécessaire ; vous pouvez pour l'acquérir vous référer au livre [[Programmation Pascal]].</text>
      <sha1>0yrfj1vbbq6oexic7u44b25knitsaph</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Assembleur/x86/Registres</title>
    <ns>0</ns>
    <id>2714</id>
    <revision>
      <id>684322</id>
      <parentid>670963</parentid>
      <timestamp>2022-08-28T11:41:02Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>/* Les registres de travaux */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4766" xml:space="preserve">{{Programmation assembleur x86}}

Dans l'architecture x86, le processeur comporte quatre registres de travail, six registres d'offset, six registres de segment, 1 registre d'état (''flags'') et un pointeur d'instruction.

== Les registres de travaux ==
[[Image:Register 8086.PNG|thumb|right|426px|Les registres du [[w:microprocesseur|microprocesseur]] Intel 8086]]
Les quatre registres de travaux sont principalement utilisés pour stocker des résultats :
* EAX : registre accumulateur (''accumulator register'').
*: Utilisé pour les opérations arithmétiques et le stockage de la valeur de retour des appels systèmes.
* EDX : registre de données (''data register'').
*: Utilisé pour les opérations arithmétiques et les opérations d'entrée/sortie.
* ECX : registre compteur (''counter register'').
*: Utilisé comme compteur par certaines instructions, permettant de répéter une série d'instructions un nombre de fois prédéterminé.
* EBX : registre de base (''base register'').
*: Utilisé comme pointeur de donnée (située dans DS en mode segmenté, segment par défaut) ou sert de base au calcul d'une adresse.

Ce sont des registres 32 bits ; pour des raisons historiques, les 16 bits de poids faible sont constitués respectivement des registres AX, DX, CX et BX.

Ces 4 registres 16 bits sont également décomposés en 8 registres de 8 bits :
* AL : octet de poids faible de AX
* AH : octet de poids fort de AX
* BL : octet de poids faible de BX
* BH : octet de poids fort de BX
* CL : octet de poids faible de CX
* CH : octet de poids fort de CX
* DL : octet de poids faible de DX
* DH : octet de poids fort de DX

La valeur initiale de ces registres à l'allumage de la machine est 0.

== Les registres d'offset ==
Les registres d'offset sont utilisés lors de l'adressage indirect de la mémoire (pointeurs). Ces registres complémentaires sont :
* EBP : (''Extended Base Pointer'') pointeur de base, utilisé dans le calcul d'adresse mémoire (segment par défaut : SS).
* ESP : (''Extended Stack Pointer'') pointeur de pile (segment par défaut : SS).
* ESI : (''Extended Source Index'') pointeur source (segment par défaut : DS).
* EDI : (''Extended Destination Index'') pointeur destination (segment par défaut : ES).

Le nom des deux derniers registres vient du fait qu'ils sont utilisés pour [[../Copie entre registres et mémoire#Transfert de séquence|la copie d'une zone mémoire vers une autre]].
Sur les processeurs x86 limités à 16 bits, ces registre n'ont pas le préfixe E et sont donc nommés : BP, SP, SI et DI.

La valeur initiale de ces registres à l'allumage de la machine est 0.

== Les registres de segment ==
La gestion de la mémoire dans l'architecture x86 est particulière : celle-ci est divisée en segments. Les registres de segment permettent d'accéder, soit au segment de programme qui est la zone mémoire des instructions de programme, soit au segment de données (zone mémoire contenant les données du programme), ou encore au segment de pile.
# CS : pointe vers les instructions du programme (''code segment'').
# DS : pointe vers les données du programme (''data segment'').
# SS : pointe vers la pile programme (''stack segment'').
# ES : pointe vers les données du programme multi-segments (''extra segment'').
# FS : pointe vers les données du programme multi-segments en mode protégé.
# GS : pointe vers les données du programme multi-segments en mode protégé.

La gestion de mémoire en multi-segments permet d'utiliser tous les registres d'offset. La plupart des systèmes d'exploitation actuels utilisent un mode protégé où tous les registres de segment pointent vers le même segment.

La valeur initiale de ces registres à l'allumage de la machine est 0, sauf CS initialisé à FFFF (hex).
En mode segmenté, cela signifie que la routine de démarrage doit se situer à l'adresse FFFF:0000 en mémoire.

== Le registre d'états ==
Chaque bit du registre EFLAGS est un indicateur d'état qui peut être modifié à chaque instruction exécutée :
* retenue (addition ou soustraction),
* dépassement,
* comparaison,
* autoriser les interruptions,
* ...

Sur les processeurs x86 limités à 16 bits, ce registre n'a pas le préfixe E et est donc nommé FLAG.

Son nom est abrégé par son initiale F dans le nom de certaines instructions.

== Le pointeur d'instruction ==
Le registre EIP est utilisé avec le segment du registre CS par le processeur pour connaitre la prochaine instruction à exécuter.
Ce registre est donc modifié implicitement par le processeur (instruction suivante, saut à l'adresse indiquée, appel d'une fonction, interruption ...).

[[en:X86 Assembly/X86 Architecture]]
[[ja:X86アセンブラ/x86アーキテクチャ]]
[[pt:Assembly x86/Registos]]</text>
      <sha1>mwcn95zxpwdjf9ydl3nwhp631hds72l</sha1>
    </revision>
  </page>
  <page>
    <title>Enseignement de l'anglais/The health, la santé</title>
    <ns>0</ns>
    <id>2907</id>
    <revision>
      <id>684303</id>
      <parentid>259256</parentid>
      <timestamp>2022-08-27T18:35:43Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1556" xml:space="preserve">to treat : ''traiter''&lt;br /&gt;to be in good health : ''être en bonne santé''&lt;br /&gt;to be in bad health : ''être en mauvaise santé''&lt;br /&gt;to cure : ''guérir''&lt;br /&gt;to recover : ''guérir''
__NOTOC__
== a disease : ''une maladie'' ==
an allergy : ''une allergie''&lt;br /&gt;asthma : ''de l'asthme''&lt;br /&gt;chicken pox : ''la varicelle''&lt;br /&gt;flu : ''la grippe''&lt;br /&gt;hepatitis : ''l'hépatite''&lt;br /&gt;jaundice : ''la jaunisse''&lt;br /&gt;mumps : ''les oreillons''&lt;br /&gt;whooping cough : ''la coqueluche''

a burn : ''une brûlure''&lt;br /&gt;a wound : ''une plaie''&lt;br /&gt;a scratch : ''une égratinure''&lt;br /&gt;a bruise : ''un bleu''&lt;br /&gt;a scar : ''une cicatrice''

blind : ''aveugle''&lt;br /&gt;blind in one eye : ''borgne''&lt;br /&gt;deaf : ''sourd''

== a medicine, a medication : ''un médicament'' ==
an antibiotic : ''un antibiotique''&lt;br /&gt;a capsule : ''une gélule''&lt;br /&gt;an ointment : ''une pommade''&lt;br /&gt;a pill : ''une pillule''&lt;br /&gt;a tablet : ''un comprimé''

== a doctor : ''un docteur'' ==
a General Practitioner (ou GP) : ''un médecin généraliste''&lt;br /&gt;an eye specialist : ''un ophtalmologiste''&lt;br /&gt;a surgeon : ''un chirurgien''&lt;br /&gt;a dentist : ''un dentiste''&lt;br /&gt;a psychiatrist : ''un psychiatre''&lt;br /&gt;a nurse : ''une infirmière''

== to breathe : ''respirer'' ==
to faint : ''s'évanouir''&lt;br /&gt;to bleed : ''saigner''&lt;br /&gt;to sprain : ''fouler''&lt;br /&gt;to break : ''fracturer, casser''&lt;br /&gt;to sneeze : ''éternuer''&lt;br /&gt;to cough : ''tousser''
&lt;br /&gt;Retour [[Enseignement de l'anglais]]

[[Catégorie:Enseignement de l'anglais (livre)|The health, la santé]]</text>
      <sha1>evt36b99ynv8zqs41zppnpxvjhjfcv0</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation GTK2 en Pascal/GtkToolItem</title>
    <ns>0</ns>
    <id>3020</id>
    <revision>
      <id>684315</id>
      <parentid>367928</parentid>
      <timestamp>2022-08-27T18:52:41Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1340" xml:space="preserve">{{Programmation GTK2 en Pascal}}
== Présentation ==
Le contrôle '''GtkToolItem''' permet de gérer un élément de barre d'outils autre qu'un bouton. En effet pour ceux-ci, il vaut mieux utiliser directement les contrôles &lt;code&gt;[[../GtkToolButton/]]&lt;/code&gt;, &lt;code&gt;[[../GtkToggleToolButton/]]&lt;/code&gt; et &lt;code&gt;[[../GtkRadioToolButton/]]&lt;/code&gt;.

=== Hiérarchie ===
{| style=&quot;border:1px #D0E2EE solid; margin=5px 5px 5px 10px;&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot; 
 | style=&quot;text-align:center;background:#EAF5FB;&quot; | Hiérarchie
 |-
 | 
 [[../GObject/]]
   └─[[../GtkObject/]]
       └─[[../GtkWidget/]]
           └─[[../GtkContainer/]]
               └─[[../GtkBin/]]
                   └─[[../GtkToolItem/]]
                       ├─[[../GtkToolButton/]]
                       └─[[../GtkSeparatorToolItem/]]
|}

== Utilisation de base ==
=== Création ===
La fonction de création d'un élément de barre d'outils est simple : 

 function gtk_tool_item_new : PGtkWidget;

Il faut ensuite créer le contrôle qu'il va contenir et l'y ajouter avec la fonction &lt;code&gt;[[../GtkContainer#Ajout et suppression d'éléments|gtk_container_add()]]&lt;/code&gt;.


{{Programmation GTK2 en Pascal/Barre d'outils}}

[[Catégorie:Programmation GTK2 en Pascal (livre)|GtkToolItem]]
[[Catégorie:Programmation GTK2 en Pascal (livre)]]</text>
      <sha1>6c1rk8if4sb18bpo13wl863knevvb7t</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation GTK2 en Pascal/GtkRadioToolButton</title>
    <ns>0</ns>
    <id>3096</id>
    <revision>
      <id>684231</id>
      <parentid>348196</parentid>
      <timestamp>2022-08-27T12:49:39Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8399" xml:space="preserve">&lt;noinclude&gt;{{Programmation GTK2 en Pascal}}&lt;/noinclude&gt;

== Présentation ==
Le contrôle '''GtkRadioToolButton''' permet de gérer un élément de barre d'outils de type bouton radio, un bouton poussoir particulier appartenant à un groupe et où un seul bouton peut être dans l'état enfoncé. Il fonctionne en fait comme un bouton radio normal géré par le contrôle &lt;code&gt;[[Programmation GTK2 en Pascal/GtkRadioButton|GtkRadioButton]]&lt;/code&gt;.

C'est une nouveauté de la version 2.6 de Gtk+.

=== Hiérarchie ===
{| style=&quot;border:1px #D0E2EE solid; margin=5px 5px 5px 10px;&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot; 
 | style=&quot;text-align:center;background:#EAF5FB;&quot; | Hiérarchie
 |-
 | 
 [[Programmation GTK2 en Pascal/GObject|GObject]]
   └─[[Programmation GTK2 en Pascal/GtkObject|GtkObject]]
       └─[[Programmation GTK2 en Pascal/GtkWidget|GtkWidget]]
           └─[[Programmation GTK2 en Pascal/GtkContainer|GtkContainer]]
               └─[[Programmation GTK2 en Pascal/GtkBin|GtkBin]]
                   └─[[Programmation GTK2 en Pascal/GtkToolItem|GtkToolItem]]
                       └─[[Programmation GTK2 en Pascal/GtkToolButton|GtkToolButton]]
                           ├─[[Programmation GTK2 en Pascal/GtkMenuToolButton|GtkMenuToolButton]]
                           └─[[Programmation GTK2 en Pascal/GtkToggleToolButton|GtkToggleToolButton]]
                               └─[[Programmation GTK2 en Pascal/GtkRadioToolButton|GtkRadioToolButton]]
|}

== Utilisation de base ==
=== Création ===
Afin de grouper les boutons radio dans une barre d'outils, Gtk+ utilise les [[Programmation GTK2 en Pascal/GSList|listes simplement chaînées de GLib]]. Les fonctions sont équivalentes à celle du contrôle &lt;code&gt;[[Programmation GTK2 en Pascal/GtkRadioButton|GtkRadioButton]]&lt;/code&gt;. Pour créer le premier bouton radio du groupe, il faut obligatoirement passer par une de ces fonctions :

 function gtk_radio_tool_button_new(group : PGSList) : PGtkToolItem;
 function gtk_radio_tool_button_new_from_stock(group : PGSList; stock_id : Pgchar) : PGtkToolItem;

Au moment de la création, le bouton radio est automatiquement ajouté à la liste &lt;code&gt;group&lt;/code&gt;. Cependant, ce paramètre n'est pas obligatoire. Nous pouvons très bien mettre NULL comme valeur et cela marchera de la même manière, sauf que nous n'aurons pas de pointeur sur la liste. La valeur de retour de cette fonction sera aussi copiée dans la variable &lt;code&gt;data&lt;/code&gt; de la liste chaînée.

La deuxième fonction de création permet de créer un bouton radio en utilisant les &lt;code&gt;[[Programmation GTK2 en Pascal/GtkStockItem|GtkStockItem]]&lt;/code&gt; qui est une structure contenant les informations sur le label et l'image à afficher. Gtk+ comporte déjà beaucoup de &lt;code&gt;GtkStockItem&lt;/code&gt; prédéfinis (en tout cas les plus courant). Le paramètre &lt;code&gt;stock_id&lt;/code&gt; est donc l'identifiant du &lt;code&gt;GtkStockItem&lt;/code&gt; à utiliser.

Ensuite pour rajouter les autres boutons au groupe, il y a plusieurs possibilités. La première est d'utiliser une des trois fonctions précédentes mais ce n'est pas tout, car autant pour le premier bouton du groupe, il n'est pas nécessaire d'avoir une liste, autant pour les autres boutons cela devient obligatoire. Pour cela, Gtk+ nous fournit une fonction qui permet d'obtenir la liste dans laquelle les boutons du groupe sont ajoutés :

 function gtk_radio_tool_button_get_group(button : PGtkRadioToolButton) : PGSList;

Avec cette fonction, nous pouvons donc connaître la liste à laquelle appartient le bouton &lt;code&gt;button&lt;/code&gt;, ce qui va nous permettre d'ajouter de nouveau bouton au groupe. Mais là où cela se complique, c'est qu'il faut récupérer la liste avant chaque ajout de bouton avec le dernier bouton ajouté comme paramètre. Voici ce que cela donnerai pour un groupe de trois boutons :

 pRadio1 := gtk_radio_tool_button_new(NULL);
 pGroup := gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(pRadio1));
 pRadio2 := gtk_radio_tool_button_new(pGroup);
 pGroup := gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(pRadio2));
 pRadio3 := gtk_radio_tool_button_new(pGroup);

Ce système peut donc s'avérer lourd lors de la création du groupe, surtout s'il contient un grand nombre de boutons. Heureusement, les concepteurs de Gtk+ ont pensé à nous simplifier la vie en ajoutant ces deux fonctions :

 function gtk_radio_tool_button_new_from_widget(group : PGtkRadioToolButton) : PGtkToolItem;
 function gtk_radio_tool_button_new_with_stock_from_widget(group : PGtkRadioToolButton; 
   stock_id : Pgchar) : PGtkToolItem;

Cette fois &lt;code&gt;group&lt;/code&gt; ne correspond pas à la liste mais à un des boutons du groupe. À chaque appel d'une de ces fonctions Gtk+ va s'occuper de récupérer correctement la liste à laquelle appartient le bouton &lt;code&gt;group&lt;/code&gt; et ajouter le nouveau bouton. Le code va être réduit et plus lisible.

Nous savons maintenant tout ce qu'il faut pour créer un groupe de &lt;code&gt;GtkRadioToolButton&lt;/code&gt;.

NB : Contrairement aux fonctions usuelles de Gtk+ de création de contrôles, ces fonctions ne renvoient pas un &lt;code&gt;PGtkWidget&lt;/code&gt; mais un &lt;code&gt;PGtkToolItem&lt;/code&gt;.

== Programme exemple ==
Nous allons créer dans une fenêtre une barre d'outils avec deux boutons radio. Le clic sur un bouton affiche son label dans la fenêtre.

Voilà le fichier &lt;code&gt;gtk046.pas&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
 program gtk046;
 
 uses glib2, gtk2;
 
 procedure gtk_toolbar_insert(toolbar : PGtkToolbar; item : PGtkToolItem; pos : gint); cdecl;
   external gtklib name 'gtk_toolbar_insert';
 
 procedure OnToggleBtn(APWidget : PGtkwidget; AData : pgpointer); cdecl;
 var
   LabelBtnRad : PGChar;
 begin
   LabelBtnRad := gtk_tool_button_get_label(GTK_TOOL_BUTTON(APWidget));
   gtk_label_set_label(GTK_LABEL(AData), LabelBtnRad);
 end;
 
 var
   pFenetre     : PGtkWidget;
   pVBox        : PGtkWidget;
   pBarreOutils : PGtkWidget;
   pBoutonRadio1 : PGtkToolItem;
   pBoutonRadio2 : PGtkToolItem;
   pLabel       : PGtkWidget;
   pGroupe      : PGSList;
 
 begin
   gtk_init(@argc, @argv);
   pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
   gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk046 : Barre d''outils');
   gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création de la GtkVBox
   pVBox := gtk_vbox_new(FALSE, 5);
   gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 
   // Création de la barre d'outils
   pBarreOutils := gtk_toolbar_new;
   gtk_box_pack_start(GTK_BOX(pVBox), pBarreOutils, FALSE, FALSE, 0);
 
   // Création des boutons radio
 //  pBoutonRadio1 := gtk_radio_tool_button_new_with_stock_from_widget(NULL, GTK_STOCK_OPEN);
 //  pBoutonRadio1 := gtk_radio_tool_button_new_from_widget(NULL);
   pBoutonRadio1 := gtk_radio_tool_button_new(NULL);
   pGroupe := gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(pBoutonRadio1));
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBoutonRadio1, -1);
   gtk_tool_button_set_label(GTK_TOOL_BUTTON(pBoutonRadio1), 'Btn 1');
 
 //  pBoutonRadio2 := gtk_radio_tool_button_new_from_widget(GTK_RADIO_TOOL_BUTTON(pBoutonRadio1));
   pBoutonRadio2 := gtk_radio_tool_button_new(pGroupe);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBoutonRadio2, -1);
   gtk_tool_button_set_label(GTK_TOOL_BUTTON(pBoutonRadio2), 'Btn 2');
 
   // Création du label
   pLabel := gtk_label_new('Label');
   gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
   // Signaux des boutons
   gtk_signal_connect(pGTKOBJECT(pBoutonRadio1), 'toggled', G_CALLBACK(@OnToggleBtn), pLabel);
   gtk_signal_connect(pGTKOBJECT(pBoutonRadio2), 'toggled', G_CALLBACK(@OnToggleBtn), pLabel);
 
   gtk_widget_show_all(pFenetre);
   gtk_main;
 end.
&lt;/syntaxhighlight&gt;

NB : ''Je n'ai pas réussi à faire fonctionner les lignes en commentaires. La barre d'outils demeure vide.''

Voilà ce que donne l'exécution du programme &lt;code&gt;gtk046&lt;/code&gt; :

[[Image:Programmation GTK2 en Pascal - gtk046-1.png]]

Et après avoir cliqué sur le deuxième bouton :

[[Image:Programmation GTK2 en Pascal - gtk046-2.png]]


{{Programmation GTK2 en Pascal/Barre d'outils}}

[[Catégorie:Programmation GTK2 en Pascal (livre)|GtkRadioToolButton]]</text>
      <sha1>fuzbwsrntiw0regnh8bqcc2dok7a3zx</sha1>
    </revision>
    <revision>
      <id>684235</id>
      <parentid>684231</parentid>
      <timestamp>2022-08-27T12:51:21Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8327" xml:space="preserve">&lt;noinclude&gt;{{Programmation GTK2 en Pascal}}&lt;/noinclude&gt;

== Présentation ==
Le contrôle '''GtkRadioToolButton''' permet de gérer un élément de barre d'outils de type bouton radio, un bouton poussoir particulier appartenant à un groupe et où un seul bouton peut être dans l'état enfoncé. Il fonctionne en fait comme un bouton radio normal géré par le contrôle &lt;code&gt;[[Programmation GTK2 en Pascal/GtkRadioButton|GtkRadioButton]]&lt;/code&gt;.

C'est une nouveauté de la version 2.6 de Gtk+.

=== Hiérarchie ===
{| style=&quot;border:1px #D0E2EE solid; margin=5px 5px 5px 10px;&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot; 
 | style=&quot;text-align:center;background:#EAF5FB;&quot; | Hiérarchie
 |-
 | 
 [[Programmation GTK2 en Pascal/GObject|GObject]]
   └─[[Programmation GTK2 en Pascal/GtkObject|GtkObject]]
       └─[[Programmation GTK2 en Pascal/GtkWidget|GtkWidget]]
           └─[[Programmation GTK2 en Pascal/GtkContainer|GtkContainer]]
               └─[[Programmation GTK2 en Pascal/GtkBin|GtkBin]]
                   └─[[Programmation GTK2 en Pascal/GtkToolItem|GtkToolItem]]
                       └─[[Programmation GTK2 en Pascal/GtkToolButton|GtkToolButton]]
                           ├─[[Programmation GTK2 en Pascal/GtkMenuToolButton|GtkMenuToolButton]]
                           └─[[Programmation GTK2 en Pascal/GtkToggleToolButton|GtkToggleToolButton]]
                               └─[[Programmation GTK2 en Pascal/GtkRadioToolButton|GtkRadioToolButton]]
|}

== Utilisation de base ==
=== Création ===
Afin de grouper les boutons radio dans une barre d'outils, Gtk+ utilise les [[Programmation GTK2 en Pascal/GSList|listes simplement chaînées de GLib]]. Les fonctions sont équivalentes à celle du contrôle &lt;code&gt;[[Programmation GTK2 en Pascal/GtkRadioButton|GtkRadioButton]]&lt;/code&gt;. Pour créer le premier bouton radio du groupe, il faut obligatoirement passer par une de ces fonctions :

 function gtk_radio_tool_button_new(group : PGSList) : PGtkToolItem;
 function gtk_radio_tool_button_new_from_stock(group : PGSList; stock_id : Pgchar) : PGtkToolItem;

Au moment de la création, le bouton radio est automatiquement ajouté à la liste &lt;code&gt;group&lt;/code&gt;. Cependant, ce paramètre n'est pas obligatoire. Nous pouvons très bien mettre NULL comme valeur et cela marchera de la même manière, sauf que nous n'aurons pas de pointeur sur la liste. La valeur de retour de cette fonction sera aussi copiée dans la variable &lt;code&gt;data&lt;/code&gt; de la liste chaînée.

La deuxième fonction de création permet de créer un bouton radio en utilisant les &lt;code&gt;[[Programmation GTK2 en Pascal/GtkStockItem|GtkStockItem]]&lt;/code&gt; qui est une structure contenant les informations sur le label et l'image à afficher. Gtk+ comporte déjà beaucoup de &lt;code&gt;GtkStockItem&lt;/code&gt; prédéfinis (en tout cas les plus courant). Le paramètre &lt;code&gt;stock_id&lt;/code&gt; est donc l'identifiant du &lt;code&gt;GtkStockItem&lt;/code&gt; à utiliser.

Ensuite pour rajouter les autres boutons au groupe, il y a plusieurs possibilités. La première est d'utiliser une des trois fonctions précédentes mais ce n'est pas tout, car autant pour le premier bouton du groupe, il n'est pas nécessaire d'avoir une liste, autant pour les autres boutons cela devient obligatoire. Pour cela, Gtk+ nous fournit une fonction qui permet d'obtenir la liste dans laquelle les boutons du groupe sont ajoutés :

 function gtk_radio_tool_button_get_group(button : PGtkRadioToolButton) : PGSList;

Avec cette fonction, nous pouvons donc connaître la liste à laquelle appartient le bouton &lt;code&gt;button&lt;/code&gt;, ce qui va nous permettre d'ajouter de nouveau bouton au groupe. Mais là où cela se complique, c'est qu'il faut récupérer la liste avant chaque ajout de bouton avec le dernier bouton ajouté comme paramètre. Voici ce que cela donnerai pour un groupe de trois boutons :

 pRadio1 := gtk_radio_tool_button_new(NULL);
 pGroup := gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(pRadio1));
 pRadio2 := gtk_radio_tool_button_new(pGroup);
 pGroup := gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(pRadio2));
 pRadio3 := gtk_radio_tool_button_new(pGroup);

Ce système peut donc s'avérer lourd lors de la création du groupe, surtout s'il contient un grand nombre de boutons. Heureusement, les concepteurs de Gtk+ ont pensé à nous simplifier la vie en ajoutant ces deux fonctions :

 function gtk_radio_tool_button_new_from_widget(group : PGtkRadioToolButton) : PGtkToolItem;
 function gtk_radio_tool_button_new_with_stock_from_widget(group : PGtkRadioToolButton; 
   stock_id : Pgchar) : PGtkToolItem;

Cette fois &lt;code&gt;group&lt;/code&gt; ne correspond pas à la liste mais à un des boutons du groupe. À chaque appel d'une de ces fonctions Gtk+ va s'occuper de récupérer correctement la liste à laquelle appartient le bouton &lt;code&gt;group&lt;/code&gt; et ajouter le nouveau bouton. Le code va être réduit et plus lisible.

Nous savons maintenant tout ce qu'il faut pour créer un groupe de &lt;code&gt;GtkRadioToolButton&lt;/code&gt;.

NB : Contrairement aux fonctions usuelles de Gtk+ de création de contrôles, ces fonctions ne renvoient pas un &lt;code&gt;PGtkWidget&lt;/code&gt; mais un &lt;code&gt;PGtkToolItem&lt;/code&gt;.

== Programme exemple ==
Nous allons créer dans une fenêtre une barre d'outils avec deux boutons radio. Le clic sur un bouton affiche son label dans la fenêtre.

Voilà le fichier &lt;code&gt;gtk046.pas&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
 program gtk046;
 
 uses glib2, gtk2;
 
 procedure gtk_toolbar_insert(toolbar : PGtkToolbar; item : PGtkToolItem; pos : gint); cdecl;
   external gtklib name 'gtk_toolbar_insert';
 
 procedure OnToggleBtn(APWidget : PGtkwidget; AData : pgpointer); cdecl;
 var
   LabelBtnRad : PGChar;
 begin
   LabelBtnRad := gtk_tool_button_get_label(GTK_TOOL_BUTTON(APWidget));
   gtk_label_set_label(GTK_LABEL(AData), LabelBtnRad);
 end;
 
 var
   pFenetre     : PGtkWidget;
   pVBox        : PGtkWidget;
   pBarreOutils : PGtkWidget;
   pBoutonRadio1 : PGtkToolItem;
   pBoutonRadio2 : PGtkToolItem;
   pLabel       : PGtkWidget;
   pGroupe      : PGSList;
 
 begin
   gtk_init(@argc, @argv);
   pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
   gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk046 : Barre d''outils');
   gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création de la GtkVBox
   pVBox := gtk_vbox_new(FALSE, 5);
   gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 
   // Création de la barre d'outils
   pBarreOutils := gtk_toolbar_new;
   gtk_box_pack_start(GTK_BOX(pVBox), pBarreOutils, FALSE, FALSE, 0);
 
   // Création des boutons radio
 //  pBoutonRadio1 := gtk_radio_tool_button_new_with_stock_from_widget(NULL, GTK_STOCK_OPEN);
 //  pBoutonRadio1 := gtk_radio_tool_button_new_from_widget(NULL);
   pBoutonRadio1 := gtk_radio_tool_button_new(NULL);
   pGroupe := gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(pBoutonRadio1));
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBoutonRadio1, -1);
   gtk_tool_button_set_label(GTK_TOOL_BUTTON(pBoutonRadio1), 'Btn 1');
 
 //  pBoutonRadio2 := gtk_radio_tool_button_new_from_widget(GTK_RADIO_TOOL_BUTTON(pBoutonRadio1));
   pBoutonRadio2 := gtk_radio_tool_button_new(pGroupe);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBoutonRadio2, -1);
   gtk_tool_button_set_label(GTK_TOOL_BUTTON(pBoutonRadio2), 'Btn 2');
 
   // Création du label
   pLabel := gtk_label_new('Label');
   gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
   // Signaux des boutons
   gtk_signal_connect(pGTKOBJECT(pBoutonRadio1), 'toggled', G_CALLBACK(@OnToggleBtn), pLabel);
   gtk_signal_connect(pGTKOBJECT(pBoutonRadio2), 'toggled', G_CALLBACK(@OnToggleBtn), pLabel);
 
   gtk_widget_show_all(pFenetre);
   gtk_main;
 end.
&lt;/syntaxhighlight&gt;

NB : ''Je n'ai pas réussi à faire fonctionner les lignes en commentaires. La barre d'outils demeure vide.''

Voilà ce que donne l'exécution du programme &lt;code&gt;gtk046&lt;/code&gt; :

[[Image:Programmation GTK2 en Pascal - gtk046-1.png]]

Et après avoir cliqué sur le deuxième bouton :

[[Image:Programmation GTK2 en Pascal - gtk046-2.png]]


{{Programmation GTK2 en Pascal/Barre d'outils}}</text>
      <sha1>34p74b65jr2jhx89l51a4izcf9taku9</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation GTK2 en Pascal/GtkSeparatorToolItem</title>
    <ns>0</ns>
    <id>3106</id>
    <revision>
      <id>684232</id>
      <parentid>348197</parentid>
      <timestamp>2022-08-27T12:50:14Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3775" xml:space="preserve">{{Programmation GTK2 en Pascal}}
== Présentation ==
Le contrôle '''GtkSeparatorToolItem''' permet de gérer un séparateur d'éléments dans une barre d'outils.

=== Hiérarchie ===
{| style=&quot;border:1px #D0E2EE solid; margin=5px 5px 5px 10px;&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot; 
 | style=&quot;text-align:center;background:#EAF5FB;&quot; | Hiérarchie
 |-
 | 
 [[Programmation GTK2 en Pascal/GObject|GObject]]
   └─[[Programmation GTK2 en Pascal/GtkObject|GtkObject]]
       └─[[Programmation GTK2 en Pascal/GtkWidget|GtkWidget]]
           └─[[Programmation GTK2 en Pascal/GtkContainer|GtkContainer]]
               └─[[Programmation GTK2 en Pascal/GtkBin|GtkBin]]
                   └─[[Programmation GTK2 en Pascal/GtkToolItem|GtkToolItem]]
                       └─[[Programmation GTK2 en Pascal/GtkSeparatorToolItem|GtkSeparatorToolItem]]
|}

== Utilisation de base ==
=== Création ===
Pour créer un séparateur, Gtk+ nous donne une fonction simple :

 function gtk_separator_tool_item_new : PGtkToolItem;

NB : Contrairement aux fonctions usuelles de Gtk+ de création de contrôles, ces fonctions ne renvoient pas un &lt;code&gt;PGtkWidget&lt;/code&gt; mais un &lt;code&gt;PGtkToolItem&lt;/code&gt;.

NB 2 : La fonction n'est pas encore définie dans les entêtes Pascal de Gtk+ de la version 1.9.8 de Free Pascal, il faut donc la définir nous-même. Cf le programme d'exemple ci-dessous.

== Programme exemple ==
Nous allons créer dans une fenêtre une barre d'outils avec deux boutons encadrant un séparateur.

Voilà le fichier &lt;code&gt;gtk047.pas&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
 program gtk047;
 
 uses glib2, gtk2;
 
 procedure gtk_toolbar_insert(toolbar : PGtkToolbar; item : PGtkToolItem; pos : gint); cdecl;
   external gtklib name 'gtk_toolbar_insert';
 function gtk_separator_tool_item_new : PGtkToolItem; cdecl;
   external gtklib name 'gtk_separator_tool_item_new';
 
 var
   pFenetre     : PGtkWidget;
   pVBox        : PGtkWidget;
   pBarreOutils : PGtkWidget;
   pBouton1     : PGtkToolItem;
   pBouton2     : PGtkToolItem;
   pSeparateur  : PGtkToolItem;
   pLabel       : PGtkWidget;
 
 begin
   gtk_init(@argc, @argv);
   pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
   gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk047 : Barre d''outils');
   gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création de la GtkVBox
   pVBox := gtk_vbox_new(FALSE, 5);
   gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 
   // Création de la barre d'outils
   pBarreOutils := gtk_toolbar_new;
   gtk_box_pack_start(GTK_BOX(pVBox), pBarreOutils, FALSE, FALSE, 0);
 
   // Création du premier bouton
   pBouton1 := gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBouton1, -1);
 
   // Création du séparateur
   pSeparateur := gtk_separator_tool_item_new;
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pSeparateur, -1);
 
   // Création du deuxième bouton
   pBouton2 := gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBouton2, -1);
   g_signal_connect(pGTKOBJECT(pBouton2), 'clicked', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création du label
   pLabel := gtk_label_new('Label');
   gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
   gtk_widget_show_all(pFenetre);
   gtk_main;
 end.
&lt;/syntaxhighlight&gt;

Voilà ce que donne l'exécution du programme &lt;code&gt;gtk047&lt;/code&gt; :

[[Image:Programmation GTK2 en Pascal - gtk047.png]]


{{Programmation GTK2 en Pascal/Barre d'outils}}

[[Catégorie:Programmation GTK2 en Pascal (livre)|GtkSeparatorToolItem]]</text>
      <sha1>0yzg19lf8ppf4ch61x8ggjjeb0lcxkf</sha1>
    </revision>
    <revision>
      <id>684233</id>
      <parentid>684232</parentid>
      <timestamp>2022-08-27T12:50:30Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3799" xml:space="preserve">&lt;noinclude&gt;{{Programmation GTK2 en Pascal}}&lt;/noinclude&gt;

== Présentation ==
Le contrôle '''GtkSeparatorToolItem''' permet de gérer un séparateur d'éléments dans une barre d'outils.

=== Hiérarchie ===
{| style=&quot;border:1px #D0E2EE solid; margin=5px 5px 5px 10px;&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot; 
 | style=&quot;text-align:center;background:#EAF5FB;&quot; | Hiérarchie
 |-
 | 
 [[Programmation GTK2 en Pascal/GObject|GObject]]
   └─[[Programmation GTK2 en Pascal/GtkObject|GtkObject]]
       └─[[Programmation GTK2 en Pascal/GtkWidget|GtkWidget]]
           └─[[Programmation GTK2 en Pascal/GtkContainer|GtkContainer]]
               └─[[Programmation GTK2 en Pascal/GtkBin|GtkBin]]
                   └─[[Programmation GTK2 en Pascal/GtkToolItem|GtkToolItem]]
                       └─[[Programmation GTK2 en Pascal/GtkSeparatorToolItem|GtkSeparatorToolItem]]
|}

== Utilisation de base ==
=== Création ===
Pour créer un séparateur, Gtk+ nous donne une fonction simple :

 function gtk_separator_tool_item_new : PGtkToolItem;

NB : Contrairement aux fonctions usuelles de Gtk+ de création de contrôles, ces fonctions ne renvoient pas un &lt;code&gt;PGtkWidget&lt;/code&gt; mais un &lt;code&gt;PGtkToolItem&lt;/code&gt;.

NB 2 : La fonction n'est pas encore définie dans les entêtes Pascal de Gtk+ de la version 1.9.8 de Free Pascal, il faut donc la définir nous-même. Cf le programme d'exemple ci-dessous.

== Programme exemple ==
Nous allons créer dans une fenêtre une barre d'outils avec deux boutons encadrant un séparateur.

Voilà le fichier &lt;code&gt;gtk047.pas&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
 program gtk047;
 
 uses glib2, gtk2;
 
 procedure gtk_toolbar_insert(toolbar : PGtkToolbar; item : PGtkToolItem; pos : gint); cdecl;
   external gtklib name 'gtk_toolbar_insert';
 function gtk_separator_tool_item_new : PGtkToolItem; cdecl;
   external gtklib name 'gtk_separator_tool_item_new';
 
 var
   pFenetre     : PGtkWidget;
   pVBox        : PGtkWidget;
   pBarreOutils : PGtkWidget;
   pBouton1     : PGtkToolItem;
   pBouton2     : PGtkToolItem;
   pSeparateur  : PGtkToolItem;
   pLabel       : PGtkWidget;
 
 begin
   gtk_init(@argc, @argv);
   pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
   gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk047 : Barre d''outils');
   gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création de la GtkVBox
   pVBox := gtk_vbox_new(FALSE, 5);
   gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 
   // Création de la barre d'outils
   pBarreOutils := gtk_toolbar_new;
   gtk_box_pack_start(GTK_BOX(pVBox), pBarreOutils, FALSE, FALSE, 0);
 
   // Création du premier bouton
   pBouton1 := gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBouton1, -1);
 
   // Création du séparateur
   pSeparateur := gtk_separator_tool_item_new;
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pSeparateur, -1);
 
   // Création du deuxième bouton
   pBouton2 := gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBouton2, -1);
   g_signal_connect(pGTKOBJECT(pBouton2), 'clicked', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création du label
   pLabel := gtk_label_new('Label');
   gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
   gtk_widget_show_all(pFenetre);
   gtk_main;
 end.
&lt;/syntaxhighlight&gt;

Voilà ce que donne l'exécution du programme &lt;code&gt;gtk047&lt;/code&gt; :

[[Image:Programmation GTK2 en Pascal - gtk047.png]]


{{Programmation GTK2 en Pascal/Barre d'outils}}

[[Catégorie:Programmation GTK2 en Pascal (livre)|GtkSeparatorToolItem]]</text>
      <sha1>k7ss3k3j6lm100okyu3gebzaoccnfk7</sha1>
    </revision>
    <revision>
      <id>684236</id>
      <parentid>684233</parentid>
      <timestamp>2022-08-27T12:51:34Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3725" xml:space="preserve">&lt;noinclude&gt;{{Programmation GTK2 en Pascal}}&lt;/noinclude&gt;

== Présentation ==
Le contrôle '''GtkSeparatorToolItem''' permet de gérer un séparateur d'éléments dans une barre d'outils.

=== Hiérarchie ===
{| style=&quot;border:1px #D0E2EE solid; margin=5px 5px 5px 10px;&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot; 
 | style=&quot;text-align:center;background:#EAF5FB;&quot; | Hiérarchie
 |-
 | 
 [[Programmation GTK2 en Pascal/GObject|GObject]]
   └─[[Programmation GTK2 en Pascal/GtkObject|GtkObject]]
       └─[[Programmation GTK2 en Pascal/GtkWidget|GtkWidget]]
           └─[[Programmation GTK2 en Pascal/GtkContainer|GtkContainer]]
               └─[[Programmation GTK2 en Pascal/GtkBin|GtkBin]]
                   └─[[Programmation GTK2 en Pascal/GtkToolItem|GtkToolItem]]
                       └─[[Programmation GTK2 en Pascal/GtkSeparatorToolItem|GtkSeparatorToolItem]]
|}

== Utilisation de base ==
=== Création ===
Pour créer un séparateur, Gtk+ nous donne une fonction simple :

 function gtk_separator_tool_item_new : PGtkToolItem;

NB : Contrairement aux fonctions usuelles de Gtk+ de création de contrôles, ces fonctions ne renvoient pas un &lt;code&gt;PGtkWidget&lt;/code&gt; mais un &lt;code&gt;PGtkToolItem&lt;/code&gt;.

NB 2 : La fonction n'est pas encore définie dans les entêtes Pascal de Gtk+ de la version 1.9.8 de Free Pascal, il faut donc la définir nous-même. Cf le programme d'exemple ci-dessous.

== Programme exemple ==
Nous allons créer dans une fenêtre une barre d'outils avec deux boutons encadrant un séparateur.

Voilà le fichier &lt;code&gt;gtk047.pas&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;pascal&quot;&gt;
 program gtk047;
 
 uses glib2, gtk2;
 
 procedure gtk_toolbar_insert(toolbar : PGtkToolbar; item : PGtkToolItem; pos : gint); cdecl;
   external gtklib name 'gtk_toolbar_insert';
 function gtk_separator_tool_item_new : PGtkToolItem; cdecl;
   external gtklib name 'gtk_separator_tool_item_new';
 
 var
   pFenetre     : PGtkWidget;
   pVBox        : PGtkWidget;
   pBarreOutils : PGtkWidget;
   pBouton1     : PGtkToolItem;
   pBouton2     : PGtkToolItem;
   pSeparateur  : PGtkToolItem;
   pLabel       : PGtkWidget;
 
 begin
   gtk_init(@argc, @argv);
   pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
   gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk047 : Barre d''outils');
   gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création de la GtkVBox
   pVBox := gtk_vbox_new(FALSE, 5);
   gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 
   // Création de la barre d'outils
   pBarreOutils := gtk_toolbar_new;
   gtk_box_pack_start(GTK_BOX(pVBox), pBarreOutils, FALSE, FALSE, 0);
 
   // Création du premier bouton
   pBouton1 := gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBouton1, -1);
 
   // Création du séparateur
   pSeparateur := gtk_separator_tool_item_new;
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pSeparateur, -1);
 
   // Création du deuxième bouton
   pBouton2 := gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
   gtk_toolbar_insert(GTK_TOOLBAR(pBarreOutils), pBouton2, -1);
   g_signal_connect(pGTKOBJECT(pBouton2), 'clicked', G_CALLBACK(@gtk_main_quit), NULL);
 
   // Création du label
   pLabel := gtk_label_new('Label');
   gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
   gtk_widget_show_all(pFenetre);
   gtk_main;
 end.
&lt;/syntaxhighlight&gt;

Voilà ce que donne l'exécution du programme &lt;code&gt;gtk047&lt;/code&gt; :

[[Image:Programmation GTK2 en Pascal - gtk047.png]]


{{Programmation GTK2 en Pascal/Barre d'outils}}</text>
      <sha1>qrt5ngkvlj73wtg68mr3l089z8nrlzd</sha1>
    </revision>
  </page>
  <page>
    <title>Blender 3D/Rendu rapide</title>
    <ns>0</ns>
    <id>4726</id>
    <revision>
      <id>684305</id>
      <parentid>449325</parentid>
      <timestamp>2022-08-27T18:44:00Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2676" xml:space="preserve">&lt;div&gt;''Sommaire : [[Blender 3D]]''&lt;/div&gt;
&lt;div&gt;''Page suivante : [[Blender 3D/Modélisation maillée|Modélisation maillée]]''&lt;/div&gt;
&lt;div&gt;&lt;small&gt;''Page précédente : [[Blender 3D/Modèle rapide|Modèle rapide]]''&lt;/small&gt;&lt;/div&gt;


[[Image:Blender first quickie render.png|180px|thumb|Votre premier rendu rapide devrait ressembler à quelque chose comme ceci.]]

Si vous n'avez pas fini le didacticiel précédent (le didacticiel [[Blender 3D/Modèle rapide|Modèle rapide]]), faites-le maintenant. Gardez le même fichier ouvert à partir de ce didacticiel parce que nous l'utiliserons ici.

Maintenant que vous avez créé votre premier modèle, vous voudrez sans doute voir son rendu. Le rendu est rapide et facile : placez-vous en ''Object Mode'' si vous en êtes sorti et appuyez tout simplement sur '''F12'''. Vous pouvez aussi cliquer sur ''Render → Render Current Frame''.

''Un '''rendu''' est la création d'une image vue de la caméra, en prenant en compte tous les effets d'environnement de votre scène, et en générant une image réaliste basée sur vos réglages. Ce premier rendu finira très vite, mais vous verrez que lorsque vos scènes 3D deviendront plus complexes, le rendu prendra du temps''.

''Si votre cube est noir, vous ne devez pas avoir de source lumineuse dans la scène. Certaines versions de Blender ne créent pas de lampe (source de lumière) par défaut, et vous devez en ajouter une. Pour ajouter une lampe, passez en ''object mode'' et appuyez sur la barre d'espace pendant que votre souris est au-dessus de la fenêtre de vue 3D. Sélectionner '''Add → Lamp''' qui vous donnera le choix pour ajouter différents types de lampes''.

Ceci est un rendu relativement simple. Il peut être arrangé un peu mais il vous donne une bonne idée de l'aspect actuel de votre modèle. Gardez à l'esprit que vous pouvez utiliser la touche '''F12''' aussi souvent que vous le voulez.

A un certain point, vous voudrez probablement enregistrer vos rendus. Au-dessus de la fenêtre de vue 3D, sélectionnez '''File → Save image…''' ou appuyez simplement sur '''F3'''. Un menu avec une liste de répertoires apparaîtra; la ligne de texte supérieure désigne le répertoire et celle inférieure vous permet de taper le nom de l'image, comme &quot;monpremierrendu.jpg&quot;—notez que Blender '''n'ajoutera pas''' l'extension &quot;.jpg&quot; automatiquement si vous quittez cette fenêtre.

&lt;div&gt;''Sommaire : [[Blender 3D]]&lt;/div&gt;
&lt;div&gt;''Page suivante : [[Blender 3D/Modélisation maillée|Modélisation maillée]]''&lt;/div&gt;
&lt;div&gt;&lt;small&gt;''Page précédente : [[Blender 3D/Modèle rapide|Modèle rapide]]''&lt;/small&gt;&lt;/div&gt;

[[Catégorie:Blender 3D (livre)|Rendu rapide]]</text>
      <sha1>1owyszc6prknfh22tigzzto6f7c5cz8</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Physique-chimie/Constitution de la matière</title>
    <ns>0</ns>
    <id>5112</id>
    <revision>
      <id>684284</id>
      <parentid>683599</parentid>
      <timestamp>2022-08-27T18:23:59Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="14247" xml:space="preserve">{{Ph s Physique-chimie}}

La matière a-t-elle une structure continue ou discontinue ? Peut-on la diviser en morceaux aussi petits que l'on veut sans en changer les propriétés ? Cette question a très longtemps divisé les philosophes. L'un des éléments en faveur de la théorie atomique est l'existence des cristaux, dont les formes géométriques font penser à des empilements réguliers de petits éléments de matière.

&lt;gallery style=&quot;text-align: center;&quot;&gt;
Image:Quartz_Brésil.jpg|Cristaux de quartz
Image:Fluorite crystals 270x444.jpg|Octaèdres de fluorite
Image:PseudoleucitaEZ.jpg|Pseudoleucite
Image:Rough diamond.jpg|Diamant brut
&lt;/gallery&gt;


Selon l'hypothèse moléculaire, la division d'un corps chimiquement défini en particules de plus en plus petites ne peut être poursuivie indéfiniment sans changer la nature de ce corps. La molécule est la plus petite fraction d'un corps susceptible d'exister à l'état libre. 
Chaque molécule, spécifique d'un composé chimique donné, peut à son tour être divisée en un certain nombre d'objets plus petits, les atomes qui caractérisent les éléments chimiques dont est formé ce composé.


== Conceptions antiques ==
La science moderne n'a fait que préciser ce concept proposé voici 25 siècles par les Grecs Leucippe et Démocrite, pour qui la nature est composée dans son ensemble de deux principes : les atomes (ce qui est plein) et le vide (ou néant). L'existence des atomes peut être déduite de ce principe : « Rien ne vient du néant, et rien, après avoir été détruit, n'y retourne. » Il y a ainsi toujours du plein, c'est-à-dire de l'être, et le non-être est le vide. Les atomes sont des corpuscules solides et indivisibles, séparés par des intervalles vides, et dont la taille fait qu'ils échappent à nos sens. Décrits comme lisses ou rudes, crochus, recourbés ou ronds (ils sont infinis par leur forme, figure et grandeur), ils ne peuvent être affectés ou modifiés à cause de leur dureté.

Si l'on s'en rapporte à l'étymologie, atome signifie &quot;que l'on ne peut couper&quot;. La réalité est un peu moins simple et depuis un siècle la conception de l'atome n'a cessé d'évoluer !

&lt;gallery&gt;
Pinacoteca Querini Stampalia - Leucippus - Luca Giordano.jpg|&lt;div style=&quot;text-align: center;&quot;&gt;Leucippe&lt;br /&gt;(vers -465 –375)&lt;br /&gt; « portrait idéal »
Demokrit.jpeg|&lt;div style=&quot;text-align: center;&quot;&gt;Démocrite&lt;br /&gt;(vers -460 -370)
Epikur.jpg|&lt;div style=&quot;text-align: center;&quot;&gt;Épicure&lt;br /&gt;(vers -342 -270)
&lt;/gallery&gt;

L'intuition géniale de Leucippe et Démocrite, née dit-on de l'observation de rais de lumière révélant la présence dans l'air de minuscules poussières invisibles à l'œil nu, fut reprise plus tard dans les théories philosophiques d'[[w:Épicure|Épicure]], pour qui l'agencement des atomes capables de vibrer sur place et de s'agréger permet la formation des substances de plus en plus complexes qui constituent le monde matériel.

Naturellement, cette conception purement matérialiste du monde a été de tous temps, et est encore, la bête noire des religieux de tous poils qui n'ont jamais hésité à la discréditer par tous les moyens imaginables. Épicure mena une vie simple et frugale mais sa théorie philosophique fut présentée comme une apologie de la débauche et de la jouissance bestiale.

== Conceptions modernes ==
Le 26 février 1896 au matin, le soleil a bien du mal à percer. Henri Becquerel, qui étudie la fluorescence de certains composés soumis à la lumière du Soleil, range son matériel dans un tiroir : quelques plaques photo sur lesquelles il pose un écran de cuivre et les sels d'uranium qui constituent le sujet de son expérience. Surprise : les plaques, développées quelques jours plus tard, sont voilées. On y distingue la silhouette de l'écran de cuivre. Un rayonnement inconnu a donc transpercé l'emballage opaque.

Henri Becquerel ne le sait pas encore, mais il vient de découvrir la radioactivité naturelle. Il pense très vite aux rayons X dont Röntgen a révélé l'existence en 1895 et dont les effets sont comparables.


Le hasard une fois de plus, mais aussi la photo, sont intervenus lors d'une découverte importante. Seulement voilà, comme dit le proverbe, chaque découverte posant de nouvelles questions, la quantité d'ignorance croît beaucoup plus vite que la quantité de savoir !


Nouvel événement : en 1897, Joseph John Thomson découvre l'électron, « grain d'électricité négative », dont il précisera la masse en 1904. Désormais, l'atome ne peut plus être considéré comme une entité insécable ! Thomson conçoit l'atome comme une sorte de « magma » chargé positivement et renfermant les électrons porteurs de charges négatives. On parle du « pudding de Thomson ».

&lt;gallery&gt;
Image:Paul Nadar - Henri Becquerel.jpg|Henri Becquerel&lt;br /&gt;(1852 - 1908)
Image:Jj-thomson2.jpg|Sir Joseph John Thomson&lt;br /&gt;(1856 - 1940)
Image:Thomsonsches atommodell.png|Le Pudding de Thomson
&lt;/gallery&gt;


Entre temps, on trouve que le thorium est lui aussi radioactif. En 1898, Pierre et Marie Curie découvrent le polonium et le radium.

&lt;gallery&gt;
Marie Curie (Nobel-Chem).jpg|Marie Curie&lt;br /&gt;(1867 - 1934)
Pierrecurie.jpg|Pierre Curie&lt;br /&gt;(1859 - 1906)
&lt;/gallery&gt;

L'activité des atomes se manifeste sous des jours divers. Les rayonnements α (alpha) et β (bêta), respectivement porteurs de charges positives et négatives, sont déviés en sens opposé lorsqu'ils traversent un champ électrique ou un champ magnétique. On sait qu'il s'agit de particules car on peut les suivre à la trace grâce au scintillement des écrans fluorescents. Les rayons γ (gamma), par contre, ne sont pas chargés électriquement. Ils traversent en ligne droite les champs électriques ou magnétiques. 

On apprend aussi que ces rayonnements sont très nocifs et qu'il convient de s'en protéger.


En 1911, chargé par Thomson de vérifier son modèle atomique, Ernest Rutherford enferme du radium dans une enceinte de plomb. Les particules α ne peuvent s'en échapper que par une petite ouverture obturée d'une mince feuille d'or. Des écrans sont disposés sur les murs de façon que l'on puisse observer leur trajectoire après qu'elles ont traversé la feuille d'or.

Rutherford observe que les particules traversent l'or en ligne droite, sauf quelques unes qui sont fortement déviées. Il en déduit que les atomes sont constitués de beaucoup de vide et d'un peu de matière très fortement concentrée dans ce qu'il nomme alors le &quot;noyau&quot; atomique. Les rares particules déviées sont celles qui ont rencontré de la matière sur leur trajectoire.

&lt;gallery&gt;
|Ernest Rutherford&lt;br /&gt;(1871 - 1937)
Image:Rutherford 1911 Solvay.jpg|Rutherford à la 1ère conférence Solvay, 1911
Image:Rutherford atom.svg|Le modèle de Rutherford
&lt;/gallery&gt;

L'atome imaginé par Rutherford est donc constitué essentiellement de vide avec des électrons qui « gravitent » à la manière des satellites autour d'un noyau très dense. On sait aujourd'hui que le diamètre du noyau est environ 100 000 fois plus petit que celui de l'atome.


C'est le Danois Niels Bohr qui le premier suggère un modèle satisfaisant pour représenter la constitution des atomes, à la lumière d'une théorie développée à partir de 1900 par Max Planck, la mécanique quantique. Théorie pas facile, et dérangeante pour l'esprit ! À l'échelle atomique, tout varie de façon discontinue, les échanges ne font intervenir que des quantités bien définies de matière, d'énergie, de rayonnement, etc., appelées quanta (pluriel latin de quantum). 

&lt;gallery&gt;
Image:Max planck.jpg|Max Planck&lt;br /&gt;(1858 - 1947)
Image:Niels Bohr.jpg|Niels Bohr&lt;br /&gt;(1885 - 1962) 
Image:Barium (Elektronenbesetzung).png|modèle de Bohr pour l'atome de baryum
Image:Albert Einstein Head.jpg|Albert Einstein&lt;br /&gt;(1879 -1955)&lt;br /&gt; par [[w:Yousuf Karsh|Yousuf Karsh]] 
&lt;/gallery&gt;

La théorie des quanta révolutionne la physique à tel point qu'Einstein écrit : ''“ses travaux [de Planck] ont donné un élan presque inégalé aux progrès de la science. Leurs effets se feront sentir tant que durera la science.”'' En 1905, Einstein lui-même va plus loin en postulant l'existence d'un corpuscule de lumière, ou photon, dont nous ne manquerons pas de reparler en temps utile. Que ferait le photographe sans les photons ?

Selon la théorie développée par Bohr en 1913, à l'image du système solaire, chaque atome est constitué d'un noyau autour duquel gravitent des électrons. La différence fondamentale avec l'atome de Rutherford est que les orbites de ces électrons correspondent obligatoirement à des niveaux d'énergie bien définis.

== Le noyau et l'atome ==

[[Image:Stylised atom with three Bohr model orbits and stylised nucleus.png|thumb|160px|right|Atome de lithium stylisé.&lt;br /&gt;Rouge : protons&lt;br /&gt;Bleu : neutrons&lt;br /&gt;Noir : électrons]]

La vision du noyau atomique se précise quand le neutron, pressenti dès 1920 par Rutherford, est découvert en 1932 par James Chadwick.

Le noyau comporte deux types essentiels de particules ou nucléons :
* les '''protons''' sont des « grains » d'électricité positive, de masse 1,66.10&lt;sup&gt;-24&lt;/sup&gt; g, ils portent une charge élémentaire e = 1,6.10&lt;sup&gt;-19&lt;/sup&gt; coulomb,
* les '''neutrons''', dont la masse est très légèrement supérieure à celle des protons, sont totalement dépourvus de charge électrique.


Quant aux '''électrons''', ils ont une masse environ 2 000 fois plus faible que celle des nucléons, 0,9.10&lt;sup&gt;-27&lt;/sup&gt; g, et ils portent une charge électrique négative opposée à celle du proton.

Les atomes étant normalement électriquement neutres contiennent donc un même nombre Z de protons et d'électrons. Ce nombre est appelé '''numéro atomique'''. Il caractérise, comme nous le verrons, chaque '''élément chimique'''.

Certains atomes de même numéro atomique contiennent un nombre différent de neutrons. Ce sont des '''isotopes'''. 

Les atomes dont les numéros atomiques sont différents mais qui contiennent le même nombre total de nucléons ('''nombre de masse''') sont des '''isobares'''.

&lt;gallery&gt;
Image:Chadwick.jpg|Sir James Chadwick&lt;br /&gt;(1891 - 1974)
Image:Wolfgang Pauli young.jpg|Wolfgang Pauli&lt;br /&gt;(1900 - 1958)
&lt;/gallery&gt;

Dans l'état normal d'un atome, chaque électron occupe une orbite stable ou « stationnaire » sur laquelle il se meut sans échanger d'énergie avec l'extérieur. Chacune des orbites possibles est caractérisée par quatre '''nombres quantiques''' qui, d'après le principe d'exclusion de Pauli, ne peuvent jamais être tous identiques pour les divers électrons d'un même atome.

Ces orbites sont réparties sur des &quot;couches électroniques&quot; baptisées K, L, M, N, O et P. Chacune de ces couches correspond à un niveau énergétique, c'est-à-dire à une valeur précise de l'énergie potentielle que possède l'électron tournant autour du noyau. Les différentes orbites électroniques peuvent dans une certaine mesure être comparées aux marches d'un escalier. Un objet que l'on y pose ne peut pas se trouver à n'importe quelle hauteur, mais seulement au niveau de l'une des marches.
Les électrons occupent normalement les orbites de plus faible niveau énergétique, les plus &quot;basses&quot;, et si l'un d'entre eux, sous l'effet d'une action extérieure, saute d'une orbite à l'autre, la quantité d'énergie mise en jeu prend une valeur bien définie, un quantum.

Wolfgang Pauli, surnommé le « fléau de Dieu » par un de ses collègues, était un physicien brillant mais aussi un homme d'une extrême intolérance. La légende de l'« effet Pauli » prétend que dès qu'il mettait les pieds dans un laboratoire, cela faisait échouer toutes les expériences en cours !

&lt;gallery&gt;
Image:IMG.svg|Irène Joliot-Curie&lt;br /&gt;(1897 - 1956)&lt;br /&gt;(2e à partir de la gauche)
|Frédéric Joliot-Curie&lt;br /&gt;(1900 - 1958)
File:Frédéric Joliot-Curie ArM.jpg|Frédéric Joliot-Curie&lt;br /&gt;(1900 - 1958)
Image:IMG.svg|Otto Hahn&lt;br /&gt;(1879 - 1968)
Image:Otto Hahn und Lise Meitner.jpg|Otta Hahn et Lise Meitner dans leur laboratoire
&lt;/gallery&gt;

Inéluctablement, la science avance. En 1934, Irène et Frédéric Joliot-Curie découvrent la radioactivité artificielle. En 1938, Otto Hahn et Fritz Strassmann découvrent la fission des atomes lourds sous l'impact des neutrons. La course à l'énergie est lancée. En 1942, Enrico Fermi fait diverger la première pile atomique à Chicago. Les applications de l'atome se diversifient, la guerre accélère les recherches...


&lt;gallery&gt;
Image:IMG.svg|Fritz Strassmann&lt;br /&gt;(1902 - 1980)
Image:Enrico Fermi 1943-49.jpg|Enrico Fermi&lt;br /&gt;(1901 - 1954)
&lt;/gallery&gt;

Aujourd'hui les physiciens savent tirer des atomes tout un bric-à-brac de particules, comme les magiciens les lapins des chapeaux. Le modèle de Bohr, même amélioré, est parfaitement dépassé, mais il nous suffira amplement.

De nouveaux modèles sont arrivés, mais nous ne les évoquerons ici que ''pour le plaisir des yeux''. Disons simplement qu'ils reposent sur des notions probabilistes.

{|
|-
|[[Image:Orbitales_d.jpg|350px|left]]
|[[Image:KWM O.jpg|200px|left]]
|-
|}

== Applications ==

Toutes ces théories ont été riches d'applications pratiques, les meilleures et les pires. Chacun connaît les utilisations de l'atome pour produire de l'énergie à des fins pacifiques ou guerrières, mais il en existe également de nombreuses autres, en particulier dans les domaines de la thérapeutique et de la photographie. Le contrôle des pièces mécaniques par gammagraphie, l'[[Photographie/Techniques scientifiques/Autoradiographie|autoradiographie]] et la [[Photographie/Techniques scientifiques/Fluorographie|fluorographie]] qui permettent d'étudier les tissus animaux ou végétaux, la scintigraphie thyroïdienne, sont autant de domaines qui peuvent intéresser les photographes. 

{|
|-
|[[Image:Centrale-nucleaire-civaux.jpg|thumb|350px|Centrale nucléaire de Civaux]]
|[[Image:Hiroshima autograph Tibbets.jpg|thumb|300px|Hiroshima après le 6 août 1945, avec la dédicace du pilote de l'Enola Gay, Paul Tibbets.&lt;br /&gt; Le massacre était-il vraiment nécessaire ?]]
|-
|}


{{Ph Physique-chimie}}</text>
      <sha1>1vt426ft5m7mbj46snbdfzyb67dk2db</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Photométrie/Étalons photométriques</title>
    <ns>0</ns>
    <id>5683</id>
    <revision>
      <id>684279</id>
      <parentid>263806</parentid>
      <timestamp>2022-08-27T18:20:00Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2549" xml:space="preserve">{{Ph s Photométrie}}


{{ébauche}}


{| border=&quot;1&quot; cellpadding=&quot;5&quot; cellspacing=&quot;0&quot; align=&quot;center&quot;
|-
|Extrait d'un article de M. Pierre Fleury, Directeur honoraire de l'Institut d'Optique de Paris. In: Revue Française de l'Electricité, n° 248, 1er trimestre 1975.&lt;br /&gt;
''L'unité d'intensité lumineuse s'est longtemps appelée bougie, du nom des sources qui la définissaient grossièrement. En 1879, Violle proposa, pour assurer une meilleure précision, l'emploi d'un bain de platine pur fondu, en train de se solidifier. Par décision internationale (1889), on lui attribua comme luminance, en direction normale, 20 bougies (dites décimales) par centimètre carré. Mais les expériences de réalisation révélèrent un manque de reproductibilité intolérable (plus de 10 %), parce que la platine réfléchissait plus ou moins la lumière du four dans lequel il était chauffé, et sur­tout parce que le métal se chargeait progressive­ment d'impuretés, notamment de silicium provenant de la réduction par une flamme hydrogénée de la silice qui l'entourait.''&lt;br /&gt;
''Aussi, bien que la définition précédente soit restée inscrite pendant cinquante ans dans la loi française, la bougie fut-elle « représentée pratiquement » par d'autres étalons. On utilisa tout d'abord, dans notre pays, la lampe Carcel à mouvement d'horlogerie, de construction spéci­fiée, consommant de l'huile de colza épurée, et ré­glée de façon à en brûler 42 grammes par heure : on lui attribuait une intensité de 9,6 bougies. D'au­tres étalons à flamme furent également en service, notamment, en Angleterre, la lampe Vernon-Harcourt au pentane, et, en Allemagne, une petite lampe à acétate d'amyle, avec une hauteur de flamme déterminée. Cette dernière définissait une bougie Hefner, valant 0,9 bougie internationale, qui fut abandonnée par la suite.''&lt;br /&gt;
''Le réglage de ces diverses sources était délicat et leur intensité très influencée par les variations des facteurs atmosphériques: pression, température, état hygrométrique ; des formules de correction furent établies pour en tenir compte, mais leur emploi laissait encore place à de grosses incertitudes.''

Une étude approfondie des réalisations successives, des bougies au corps noir, se trouve dans ''Étalons photométriques'' par P. FLEURY. Revue d'Optique, éd. 1932.
|-
|}

== Images en réserve ==

&lt;gallery&gt;
Image:Harcourt pentane air-lamp.jpg|Lampe au pentane Vernon-Harcourt
&lt;/gallery&gt;


{{Ph Photométrie}}
[[Catégorie:À compléter]]</text>
      <sha1>ipi0bht5i4587w9vxs1828rinm2i0ro</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Opérateurs</title>
    <ns>0</ns>
    <id>5713</id>
    <revision>
      <id>684243</id>
      <parentid>672510</parentid>
      <timestamp>2022-08-27T12:56:11Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10647" xml:space="preserve">&lt;noinclude&gt;{{Programmation Python}}&lt;/noinclude&gt;

== Définition ==

Un ''opérateur'' est un symbole (ou un mot réservé) utilisé pour effectuer une ''opération'' entre des ''opérandes''.

Une opérande est une variable, un littéral ou bien une expression.

Une expression est une suite valide d'opérateurs et d'opérandes.

Par exemple, dans l'expression :
 x = y + 1

Il y a deux opérateurs ( = et +) et trois opérandes (x, y et 1).

Certains opérateurs peuvent avoir des comportements différents en fonction des types d'opérandes sur lesquels ils agissent : on parle alors de ''surcharge des opérateurs''. Exemple :
* &quot;+&quot; additionne des nombres, mais concatène des chaînes de caractères.
* &quot;*&quot; multiplie des nombres entre eux, mais duplique des chaînes de caractères.

Il existe différentes catégories d'opérateur :

==       Présentation des différents opérateurs       ==

=== les opérateurs d'affectation ===
* '='
* Affectation multiple, e.g. &lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;x = y = z = 3&lt;/syntaxhighlight&gt;
* Affectation parallèle, e.g. &lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;x, y = 1 , 0.5&lt;/syntaxhighlight&gt;
* Affectation avec opération : la variable est utilisée comme opérande de gauche et utilisée pour stocker le résultat :
:&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
a = 5
a *= 2  #  10
a += 1  #  11
a /= 4  #   2.75
&lt;/syntaxhighlight&gt;

=== les opérateurs logiques ===

Les expressions avec un opérateur logique sont évaluées à 0 ou 1 pour chaque bit des opérandes entiers.
Pour chaque bit des opérandes X et Y :
* X '''|''' Y : OU logique. &lt;br&gt;Si le bit de X ou le bit de Y est évalué à 1, alors le bit résultant sera 1.   &lt;br /&gt;Sinon, le bit résultant sera 0.
* X '''^''' Y : OU exclusif logique. &lt;br&gt;Si le bit de X est différent du bit de Y, alors le bit résultant sera 1.   &lt;br /&gt;Sinon, le bit résultant sera 0.
* X '''&amp;''' Y : ET logique. &lt;br&gt;Si le bit de X et le bit de Y sont tous les deux évalués à 1, alors le bit résultant sera 1.   &lt;br /&gt;Sinon, le bit résultant sera 0.
* ~ X : NON logique.&lt;br&gt;Le bit résultant est la valeur opposée du bit de X.

=== les opérateurs booléens ===
Les expressions avec un opérateur booléen sont évaluées à &lt;code&gt;True&lt;/code&gt; ou &lt;code&gt;False&lt;/code&gt;.

* X '''or''' Y : OU booléen. &lt;br&gt;Si X est évalué à &lt;code&gt;True&lt;/code&gt;, alors l'expression est &lt;code&gt;True&lt;/code&gt; et Y n'est pas évalué. &lt;br /&gt;Sinon, l'expression est évaluée à la valeur booléenne de Y.
* X '''and''' Y : ET booléen. &lt;br&gt;Si X est évalué à &lt;code&gt;False&lt;/code&gt;, alors l'expression est &lt;code&gt;False&lt;/code&gt; et Y n'est pas évalué. &lt;br /&gt;Sinon, l'expression est évaluée à la valeur booléenne de Y.
* '''not''' X : NON booléen.&lt;br&gt;Evalué à la valeur booléenne opposée de X.

En fait, ces opérateurs supportent n'importe quel type d'opérandes car ils sont convertis implicitement en valeur booléenne pour l'évaluation :
* Un entier est converti à &lt;code&gt;False&lt;/code&gt; s'il vaut 0, et à &lt;code&gt;True&lt;/code&gt; sinon ;
* Une chaîne de caractère, un tableau ou un dictionnaire est converti à &lt;code&gt;False&lt;/code&gt; si elle / s'il est vide, et à &lt;code&gt;True&lt;/code&gt; sinon. Il s'agit du même comportement que le précédent sur les entiers en utilisant le résultat de la fonction &lt;code&gt;len()&lt;/code&gt; donnant la taille sous la forme d'un entier.

&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; not ''      # Chaîne vide
True
&gt;&gt;&gt; not 'abc'   # Chaîne non vide
False
&gt;&gt;&gt; not 'False' # Chaîne non vide
False
&gt;&gt;&gt; not 'True'  # Chaîne non vide
False
&lt;/syntaxhighlight&gt;

Pour les opérateurs &lt;code&gt;or&lt;/code&gt; et &lt;code&gt;and&lt;/code&gt; avec des opérandes non-booléens, le comportement est donc le suivant
* X '''or''' Y : Retourne X si X équivaut à &lt;code&gt;True&lt;/code&gt;, sinon retourne Y.
* X '''and''' Y : Retourne X si X équivaut à &lt;code&gt;False&lt;/code&gt;, sinon retourne Y.

&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; 0 or 1
1
&gt;&gt;&gt; 0 and 1
0
&lt;/syntaxhighlight&gt;

=== les opérateurs de comparaisons ===
Tout comme les opérateurs logiques, les opérateurs de comparaison renvoient une valeur booléenne &quot;True&quot; ou &quot;False&quot;. Les opérateurs de comparaisons s'appliquent sur tous les types de base.

* '''&lt;''' strictement inférieur
* '''&gt;''' strictement supérieur
* '''&lt;=''' inférieur ou égal
* '''&gt;=''' supérieur ou égal
* '''==''' égal
* '''!=''' différent
* '''&lt;&gt;''' différent, on utilisera de préférence !=
* X '''is''' Y : X et Y représentent le même objet.
* X '''is not''' Y : X et Y ne représentent pas le même objet

Il est possible d'enchaîner les opérateurs : X &lt; Y &lt; Z, dans ce cas, c'est Y qui est pris en compte pour la comparaison avec Z et non pas l'évaluation de (X &lt; Y) comme on pourrait s'y attendre dans d'autres langages.

=== les opérateurs mathématiques ===

{| class=&quot;wikitable altlines1&quot; border=&quot;1&quot;
! symbole
! opération
! types
! exemples
|-
| +
| Addition
| entier, réel
chaîne de caractères
| 6+4 == 10
&quot;a&quot; + &quot;b&quot;== &quot;ab&quot;
|-
| -
| Soustraction
| entier, réel
| 6-4 == 2
|-
| *
| Multiplication
| entier
réel

chaîne de caractères
| 6*4 == 24
1.2 * 1 == 1.2

3 * &quot;s&quot; == &quot;sss&quot;
|-
|**
| Puissance
|entier, réel
|12**2 == 144
|-
| /
| Division
| entier
réel
| 6/4 == 1 &lt;small style=&quot;color:red;&quot;&gt;(Python 2)&lt;/small&gt;    1.5 &lt;small style=&quot;color:red;&quot;&gt;(Python 3)&lt;/small&gt;
6./4 == 1.5
|-
| //
| Division entière
| entier, réel
| 6''//''4 == 1
|-
| %
| Modulo
| entier, réel
| 6%4 == 2
|}
La division entre deux entiers produit un entier en Python 2, et un nombre à virgule flottante en Python 3.

&lt;syntaxhighlight lang=&quot;Python3&quot;&gt;
&gt;&gt;&gt; 8/4
2.0
&gt;&gt;&gt; 8//4
2
&lt;/syntaxhighlight&gt;

{| style=&quot;width:100%;&quot;
|+ Comportement de la division entière et du modulo selon le signe des opérandes
|
&lt;syntaxhighlight lang=&quot;Python3&quot;&gt;
&gt;&gt;&gt; 7 // 4
1
&gt;&gt;&gt; -7 // 4
-2
&gt;&gt;&gt; 7 // -4
-2
&gt;&gt;&gt; -7 // -4
1
&lt;/syntaxhighlight&gt;
|
&lt;syntaxhighlight lang=&quot;Python3&quot;&gt;
&gt;&gt;&gt; 7 % 4
3
&gt;&gt;&gt; -7 % 4
1
&gt;&gt;&gt; 7 % -4
-1
&gt;&gt;&gt; -7 % -4
-3
&lt;/syntaxhighlight&gt;
|}

{{../Tableau des opérateurs}}

== Opérateurs et expressions ==

On manipule les valeurs et les variables qui les référencent, en les combinant avec des opérateurs pour former des expressions. Exemple :

&lt;code&gt;a, b = 7.3, 12&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;y = 3*a + b/5&lt;/code&gt;

Dans cet exemple, nous commençons par affecter aux variables &quot;&lt;code&gt;a&lt;/code&gt;&quot; et &quot;&lt;code&gt;b&lt;/code&gt;&quot; les valeurs &quot;&lt;code&gt;7,3&lt;/code&gt;&quot; et &quot;&lt;code&gt;12&lt;/code&gt;&quot;. Python assigne automatiquement le type « réel » à la variable &quot;&lt;code&gt;a&lt;/code&gt;&quot;, et le type « entier » à la variable &quot;&lt;code&gt;b&lt;/code&gt;&quot;.

La seconde ligne de l'exemple consiste à affecter à une nouvelle variable &quot;&lt;code&gt;y&lt;/code&gt;&quot; le résultat d'une expression qui combine les ''opérateurs'' &quot;*&quot;, &quot;+&quot; et &quot;/&quot; avec les ''opérandes'' &quot;&lt;code&gt;a&lt;/code&gt;&quot;, &quot;&lt;code&gt;b&lt;/code&gt;&quot;, &quot;&lt;code&gt;3&lt;/code&gt;&quot; et &quot;&lt;code&gt;5&lt;/code&gt;&quot;. Les opérateurs sont les symboles spéciaux utilisés pour représenter des opérations mathématiques simples, telles l'addition ou la multiplication. Les opérandes sont les valeurs combinées à l'aide des opérateurs.

Python évalue chaque expression qu'on lui soumet, aussi compliquée soit-elle, et le résultat de cette évaluation est toujours lui-même une valeur. À cette valeur, il attribue automatiquement un type, lequel dépend de ce qu'il y a dans l'expression. Dans l'exemple ci-dessus, la variable &quot;&lt;code&gt;y&lt;/code&gt;&quot; sera du type réel, parce que l'expression évaluée pour déterminer sa valeur contient elle-même au moins un réel.

Les opérateurs Python ne sont pas seulement les quatre opérateurs mathématiques de base. Il faut leur ajouter l'opérateur &quot;**&quot; pour l'exponentiation, ainsi qu'un certain nombre d'opérateurs logiques, des opérateurs agissant sur les chaînes de caractères, des opérateurs effectuant des tests d'identité ou d'appartenance, etc.

Signalons au passage la disponibilité de l'opérateur modulo, représenté par le symbole &quot;%&quot;.
Cet opérateur fournit le reste de la division entière d'un nombre par un autre. Essayez par exemple :

&lt;pre&gt;
&gt;&gt;&gt; 10 % 3  # 1
&gt;&gt;&gt; 10 % 5  # 0
&lt;/pre&gt;

Cet opérateur pourra être utile notamment pour tester si un nombre &quot;a&quot; est divisible par un nombre &quot;b&quot;. Il suffira en effet de vérifier que &quot;a % b&quot; donne un résultat égal à zéro.

{{exercices}}
&lt;ol&gt;
&lt;li&gt;Testez les lignes d'instructions suivantes :&lt;/li&gt;
&lt;pre&gt;
&gt;&gt;&gt;  r , pi = 12, 3.14159
&gt;&gt;&gt;  s = pi * r**2
&gt;&gt;&gt;  print(s)
452.38896
&gt;&gt;&gt;print(type(r), type(pi), type(s))
&lt;type 'int'&gt;, &lt;type 'float'&gt;, &lt;type 'float'&gt;
&lt;/pre&gt;
&lt;/ol&gt;
{{solution}}
On constate qu'une variable appartenant à l'ensemble des nombres entiers, multipliée par un nombre décimal, donne un décimal.
{{fin}}

== Composition ==

Jusqu'ici nous avons examiné les différents éléments d'un langage de programmation, à savoir : les ''variables'', les ''expressions'' et les ''instructions'', mais sans traiter de la manière dont nous pouvons les combiner les unes avec les autres.

Or l'une des grandes forces d'un langage de programmation de haut niveau est qu'il permet de construire des instructions complexes par assemblage de fragments divers. Ainsi par exemple, si vous savez comment additionner deux nombres et comment afficher une valeur, vous pouvez combiner ces deux instructions en une seule :

&lt;pre&gt;
&gt;&gt;&gt; print(17 + 3)
20
&lt;/pre&gt;

Cela n'a l'air de rien, mais cette fonctionnalité qui paraît si évidente va vous permettre de programmer des algorithmes complexes de façon claire et concise. Exemple :

&lt;pre&gt;
&gt;&gt;&gt; h, m, s = 15, 27, 34
&gt;&gt;&gt; print(&quot;nombre de secondes écoulées depuis minuit = &quot;, h*3600 + m*60 + s)
&lt;/pre&gt;

'''Attention :'''

Il y a une limite à ce que vous pouvez combiner ainsi.  Le symbole pour l'égalité en mathématique est  '='. Le symbole pour l'égalité en programmation Python est  '=='

Ainsi par exemple,

* En mathématique : a + 1 = b   ( '=' est symbole de l'égalité et ici on a une équation).  m + 1 = b  et  a * x = b  sont ici des équations mathématiques. Cette forme d’écriture est inutilisable pour modifier une variable en programmation.

* En programmation (Python et dans d'autres langages) : on peut écrire &lt;code&gt;a = a + 1&lt;/code&gt;  ( '=' est l'opérateur d'affectation, symbole d'affectation).  On affecte à la variable a, à gauche, un nouveau contenu. Cela signifie ici (en programmation uniquement) que la nouvelle valeur de a ( à gauche du signe d'affectation)  va être remplacée par l'ancienne valeur de a ( à droite du signe d'affectation)   incrémentée ici  de la valeur 1. Avec &lt;code&gt;a = a - 2&lt;/code&gt; on décrémente la variable a de la valeur 2.

Nous aurons l'occasion de revenir bientôt sur ce sujet. Mais auparavant, il nous faut encore aborder un autre concept de grande importance.

== Références ==
{{Références}}</text>
      <sha1>osmg9oosci90ku0garlvl3ylvg1xdup</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation PHP</title>
    <ns>0</ns>
    <id>6754</id>
    <revision>
      <id>684226</id>
      <parentid>659336</parentid>
      <timestamp>2022-08-27T12:46:00Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2031" xml:space="preserve">{{NavDébut|book={{PAGENAME}}|page=Introduction|pageText=Démarrer}}
{{Entête livre/début|
[[Image:Webysther 20160423 - Elephpant.svg|100px|center]]
''un livre appartenant à la série [[Programmation]]&lt;br/&gt;et à l'[[Accueil/Informatique|étagère Informatique]] de [[Accueil|Wikilivres]]''.
}}

{{Version imprimable}}
{{version PDF}}
{{moteur}}
{{autres projets
 |w=PHP
 |wikt=PHP
 |v=PHP
}}
{{lecture conseillée|[[Programmation]]}}
{{:Programmation PHP/Sommaire}}
----
** [[S'initier au Zend Framework|Zend Framework]]
----
* '''CMS'''
** [[Dotclear]]
** [[Drupal]]
** [[MediaWiki pour débutants]]
** [[Piwik]]
** [[WordPress]]

== Voir aussi ==
* [[Coder_avec_Unicode/Conversion#PHP]]
* [[Media:Cours_php.pdf|Cours PHP.pdf]], Sébastien ROHAUT, 21 juillet 2012
*[http://www.php.net Le site officiel PHP (anglais, documentation française disponible sur le site)]
*[http://www.apprendre-php.com Apprendre-PHP.com : apprendre PHP rapidement par la pratique avec de nombreux tutoriels et portions de code prêtes à l'emploi]
*[http://www.siteduzero.com/tutoriel-3-14668-concevez-votre-site-web-avec-php-et-mysql.html Tutoriel PHP quasi-complet, pour débutants s'étendant jusqu'aux EXPREG, la librairie GD et les BD sur le] [http://www.siteduzero.com Site du Zéro]
*[http://www.phpdebutant.org Php Débutant]
*[http://www.phpindex.com PhpIndex.com]
*[http://www.phpscripts-fr.net PhpScripts.com :: Des exemples de scripts PHP]
*[http://www.nexen.net Nexen.net]
*[http://www.phpfrance.com PhpFrance]
*[http://php.developpez.com/ Developpez.com PHP et MySQL]
*[http://www.math-linux.com/article.php3?id_article=25 Installation d’un serveur LAMP : Linux Apache MySQL PHP]
*[http://www.math-linux.com/article.php3?id_article=31 Introduction au langage PHP]
*[http://www.webmaster-debutant.net Webmaster-Debutant.net (cours et tutoriels)]
{{Entête livre/fin|footer=1}}

__NOEDITSECTION__
{{CDU|6/68/681|681.3/681.3.0}}

[[Catégorie:PHP]]
[[Catégorie:Livres en cours de rédaction]]
[[Catégorie:Programmation PHP (livre)|*]]</text>
      <sha1>66gkk943h0e76lxgotxow72onlhmclf</sha1>
    </revision>
  </page>
  <page>
    <title>Jeu de go/Ressources</title>
    <ns>0</ns>
    <id>9124</id>
    <revision>
      <id>684318</id>
      <parentid>504820</parentid>
      <timestamp>2022-08-27T18:54:20Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2501" xml:space="preserve">{{Jeu de go}}
[[Image:Go board.jpg|300px|right|thumb|Un goban traditionnel]]
{{lienDePage|Jeu de go|Comment apprendre|}}

== Logiciels de jeu de go ==
* [http://canut-ki-in.jeudego.org/simulation_influence/ Simulateur d'influence], programme pédagogique (basé Web) qui dessine des &quot;cartes&quot; de parties de go. Visualisation de l'influence, tension, concentration et instabilité.
* [http://www.jeudego.com/GoTeacher/index.htm JeudeGo Teacher], un CD-ROM d'initiation
* [http://lie.math.brocku.ca/GoTools/applet.html GoTools], un programme de résolution de problèmes de vie et mort, de niveau professionnel ''(ces problèmes, dans des espaces limités et avec des objectifs clairs, sont à peu près le seul domaine où les résultats en intelligence artificielle sont comparables à ceux des échecs)''
* [http://ricoh51.free.fr/index.htm Dariush], un logiciel pour jouer en 9x9, 13x13 et 19x19, résoudre des problèmes, apprendre les josekis, ainsi qu'un client graphique pour GNUGo. Permet aussi de jouer sur IGS.
* [http://ricoh51.free.fr/index.htm Dariush3D], un logiciel pour jouer au Go en 9x9, 13x13 et 19x19, à AtariGo en 3x3 .. 9x9, contre lui ou en réseau.
* [http://www.sente.ch/software/goban/ Goban], un client graphique pour gnugo et IGS, sous Macintosh OS X
* [http://www.godrago.net Drago], un éditeur de parties permettant de rejouer des problèmes ou des parties, de jouer contre GNUGo, et d'imprimer ou d'exporter des figures ou des parties complètes.
* [http://www.cs.ualberta.ca/~mmueller/cgo/survey/twogames.html Two Representative Computer Go Games], article dans lequel Martin Müller commente deux parties jouées contre des ordinateurs.
* [http://www.cns.nyu.edu/~mechner/go/ The Game of Go], page de David A. Mechner, joueur de go et programmeur, avec notamment une analyse du véritable niveau actuel des programmes de go.
* [[w:GNU Go|GNU Go]]

== Jouer sur Internet ==
* KGS (KGS Go Server): http://www.gokgs.com/ (Java 1.3) avec une salle de jeu française où on trouve des cours (gratuits), des conseils… 
* IGS (Internet Go Server) : http://www.pandanet.co.jp/English/
* FICGS (Free Internet Chess and Go Server) : http://www.ficgs.com/
* NNGS (No Name Go Server) : http://nngs.cosmic.org/
* Dragon Go Server : http://www.dragongoserver.net/ serveur de jeu « tour par tour »
* JeudeGo : http://jeudego.org apprendre et freeware
* Yahoo Games : http://games.yahoo.com

{{lienDePage|Jeu de go|Comment apprendre|}}

[[Catégorie:Jeu de Go (livre)|Ressources]]</text>
      <sha1>js3lvxnn5s5gmmclzy7k6wbg9jomvit</sha1>
    </revision>
  </page>
  <page>
    <title>Japonais/Présentation</title>
    <ns>0</ns>
    <id>9259</id>
    <revision>
      <id>684298</id>
      <parentid>657251</parentid>
      <timestamp>2022-08-27T18:32:14Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="860" xml:space="preserve">&lt;div style=&quot;text-align: center;&quot;&gt;
{| CELLPADDING=&quot;10&quot;
|
&lt;div style=&quot;text-align: center;&quot;&gt;&lt;span style=&quot;display:table-cell; border-collapse:collapse; border: none;&quot;&gt;[[Image:Nuvola Japan flag.svg|125px]]&lt;/span&gt;&lt;/div&gt;
|
|| 
&lt;div style=&quot;text-align: center;&quot;&gt;&lt;span style=&quot;font-size:25px;&quot;&gt;'''Japonais'''&lt;/span&gt;&lt;br /&gt;
&lt;strong&gt;Apprentissage du Japonais&lt;/strong&gt;&lt;/div&gt;
|}
&lt;/div&gt;

Ce Wikilivre est une introduction à l'ensemble de la langue japonaise. Vous y trouverez des '''[[Japonais/Vocabulaire|glossaires]]''', une '''[[:Catégorie:Méthode de Japonais|méthode]]''' d'apprentissage de la langue et des points de '''[[Japonais/Grammaire|grammaire]]''' détaillés.


{| border=&quot;1&quot; cellspacing=&quot;0&quot; cellpadding=&quot;6&quot; align=&quot;center&quot;
| style=&quot;background-color:#77777720;&quot; | これは日本語の表示テストです。
|}

[[Catégorie:Japonais (livre)|Présentation]]</text>
      <sha1>lqsnd3f7ng5np448q1zotg29ffgyarf</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Glossaire</title>
    <ns>0</ns>
    <id>10381</id>
    <revision>
      <id>684273</id>
      <parentid>429874</parentid>
      <timestamp>2022-08-27T18:14:12Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25163" xml:space="preserve">{{Ph s Glossaire}}

== . A ==

* '''abaque''' : nom masculin, désigne un graphique, utilisé de préférence à des formules mathématiques, pour connaître certains paramètres en fonction de diverses données. On utilise des abaques pour déterminer, par exemple, le temps de développement d'un film en fonction de la température et du type de révélateur utilisé, l'angle de champ d'un objectif en fonction de sa distance focale, etc.

* '''[[aberration]]''' : défaut d'un système optique aboutissant à la formation d'images imparfaites.

* '''achromatique''' : un objectif achromatique parfait assurerait la transmission de la lumière blanche sans aucune dispersion. Un doublet achromatique est constitué de deux lentilles accolées pour tenter de se rapproché de la définition donnée ci-dessus.

* '''ACL''' : Affichage à Cristaux Liquides, en anglais '''LCD''' = ''Liquid Crystal Display''.

* '''[[acutance]]''' : aptitude d'un film à traduire de façon marquée la délimitation de deux zones de [[densité optique]] différente.

* '''Adaptall''' : dénomination d'une série d'objectifs commercialisés par [[Tamron]] et pourvus d'une bague arrière interchangeable permettant leur montage sur des boîtiers reflex de la plupart des grandes marques. 

* '''AE''' : ''Auto Exposure'', système d'exposition automatique utilisable avec priorité à l'ouverture, à la vitesse ou en mode programme.

* '''AF''' : ''Auto Focus'', système de mise au point automatique. 

* '''[[affaiblisseur]]''' : bain chimique permettant de diminuer la densité d'une image argentique. 

* '''[[agrandisseur]]''' : appareil composé d'une boîte à lumière, d'un porte-film et d'un objectif permettant de projeter l'image d'un négatif sur un papier sensible.

* '''[[anamorphose]]''' : déformation d'une image de façon non homothétique à l'aide d'un système optique du type miroir cylindrique, miroir conique, lentille cylindrique, association de prismes, etc. Dans les systèmes de cinéma panoramique, on comprime l'image dans le sens de la largeur de la pellicule, de façon à la faire tenir dans le format rectangulaire traditionnel, puis à la projection on réalisé l'opération inverse. Il faut utiliser un système [[anamorphoseur]] à la prise de vue, et un autre à la projection.

* '''anastigmat''' : objectif parfaitement corrigé de l'[[astigmatisme]] ; on devrait dire « stigmat » pour éviter la double négation 

* '''[[angle de champ]]''' : angle qui caractérise l'aptitude d'un objectif à donner une image nette de ce qui se trouve dans une portion de l'espace plus ou moins grande. Généralement cet angle est donné en fonction de la diagonale du format utilisé à la prise de vue. Pour un format donné, il est d'autant pus petit que la distance focale de l'objectif est plus grande, et inversement.

* '''[[anneaux de Newton]]''' : auréoles plus ou moins irisées qui se produisent lorsque deux surfaces lisses mais pas parfaitement congrues sont mises en contact. Il s'agit en fait d'un phénomène d'[[interférences]], qui se produit par exemple quand une diapositive est montée sous verre, ou lorsqu'un négatif est en contact imparfait avec le passe-vues de l'agrandisseur.

* '''anti-halo''' : couche située au dos d'un film ou d'une plaque photographique et destinée à absorber la lumière qui a traversé l'émulsion pour empêcher qu'elle soit réfléchie ou diffusée, ce qui provoquerait la formation de halos autour des zones sombres du négatif, donc autour des lumières du positif correspondant.

* '''[[Photographie/Appareils/Systèmes antipoussières|antipoussières (systèmes)]]''' : systèmes automatiques évitant le dépôt de poussières sur les capteurs des appareils photo numériques.

* '''[[anti-reflets]]''' : se dit d'un traitement superficiel appliqué aux surfaces optiques pour supprimer la réflexion de la lumière sur les surfaces air-verre et améliorer sa transmission à travers les diverses lentilles et autres pièces optiques. La suppression des reflets augmente la luminosité des objectifs, améliore la transmission du contraste et diminue la formation d'images parasites susceptibles d'altérer les images.

* '''[[aplanat]]''' : objectif de type ancien constitué généralement de deux doublets achromatiques placés en vis-à-vis, de part et d'autre du [[diaphragme]], et permettant d'obtenir une image plane d'un objet plan. 

* '''apochromatique''' : se dit d'un objectif dont l'[[aberration chromatique]] est particulièrement bien corrigée. Les objectifs apochromatiques sont avant tout destinés à des applications techniques telles que la [[reproduction des documents]] ou l'obtention de grandissements très élevé, comme c'est le cas avec les [[téléobjectif]]s puissants dont certains reçoivent l'appellation « APO ».

* '''armement''' : action d'« armer » l'[[obturateur]] d'un appareil photo, c'est-à-dire de le mettre en état de fonctionner. Avec la plupart des appareils argentiques, l'armement est réalisé en même temps que l'avance du film, à l'aide d'un levier ou d'un moteur.

* '''ASA''' : ''American Standard Association'', organisme de normalisation états-unien chargé de définir des spécifications industrielles. La sensibilité des pellicules était caractérisée par une valeur ASA variant selon une [[progression arithmétique]] faisant par exemple qu'un film de 50 ASA est deux fois moins sensible qu'un autre de 100 ASA ou 8 fois moins sensible qu'un troisième de 400 ASA.

* '''ASR''' : ''Advanced Shake Reduction'', réduction du flou de bougé dû aux mouvements intempestifs de l'appareil, système utilisé par [[Samsung]].

* '''astigmate''' : se dit d'un système optique présentant un défaut tel que la distance de mise au point de lignes droites dépend de leur direction. Un œil astigmate présente des irrégularités de courbure de cornée ou des défauts d'homogénéité du cristallin qui produisent ce défaut, dit défaut de [[stigmatisme]] ou astigmatisme. Un objectif ''anastigmat'' est parfaitement dépourvu d'astigmatisme ; on devrait dire ''stigmat'' pour éviter la double négation.

* '''autofocus''' : système permettant de réaliser automatiquement la [[mise au point]]. Ce système a été d'abord installé sur les projecteurs de diapositives, où il se révèle fort utile pour contrer la perte de mise au point due au bombement des diapositives sous l'effet de la chaleur. Les systèmes autofocus ont été par la suite généralisés sur les appareils de prise de vues, d'abord argentiques, puis numériques.

* '''''available light''''' : littéralement lumière disponible, plus simplement lumière ambiante, on fait avec ce que l'on a, sans apporter de sources d'éclairage particulières.

* '''axe optique''' : axe de symétrie d'un système optique, ou d'une partie de système optique.

== . B ==

* '''[[bascule]]''' : dispositif grâce auquel l'axe optique de l'objectif peut être incliné par rapport à la perpendiculaire au plan du film ; ce mouvement permet dans certaines conditions d'augmenter la [[profondeur de champ]].

* '''bitmap''' : littéralement « carte de points », se dit d'une image informatique définie point par point lors de son affichage ou de son impression, c'est-à-dire dont les [[Photographie/Glossaire#. P|pixels]] sont définis un par un. Voir [[Photographie/Les premiers pas/Qu'est-ce qu'une image numérique ?|ici]].

* '''[[bokeh]]''' : mot d'origine japonaise qui désigne l'aspect que prennent les images des objets qui ne se trouvent pas dans le plan de mise au point de l'appareil.

* '''brillance''' : ancien nom de la [[luminance]].

* '''bromure d'argent''' : sel d'argent qui constitue l'élément sensible de la plupart des films et papiers photographiques.

== . C ==
* '''C41''' : procédé actuel de traitement des négatifs couleurs, version [[Photographie/Fabricants/Kodak|Kodak]].
* '''caméra''' : en France, désigne un appareil de prise de vues cinématographiques ; en anglais et en allemand, le mot « camera » désigne un appareil de prise de vus en général, attention par conséquent aux possibilités de confusion.
* '''carbonate''' (de sodium ou de potassium) : sel utilisé en tant qu'accélérateur dans les [[révélateur]]s ; l'action du carbonate de potassium est plus importante que celle du carbonate de sodium.
* [[Photographie/Surfaces sensibles/Formats de surfaces sensibles|cartouche]] : petit conteneur en tôle ou en matière plastique contenant un certain métrage de film argentique.
* '''catadioptrique''', se dit d'un ensemble optique comportant des lentilles et des miroirs.
* '''catathermique''' : se dit des verres absorbant l'infrarouge, utilisés dans les agrandisseurs et les projecteurs pour protéger de la chaleur les négatifs, les diapositives ou les films.
* '''CdS''' : symbole chimique du sulfure de cadmium, corps utilisé comme éléments sensible dans certains posemètres ou cellules photoélectriques.
* '''CF''' : ''Compact Flash'', format de carte-mémoire.
* '''chromatisation''' : opération qui consiste, à l'aide de colorants appropriés, à étendre la sensibilité chromatique d'une émulsion au-delà de la sensibilité naturelle au bleu-violet du bromure d'argent.
* '''close-up''' : [[photographie rapprochée]].
* '''coma''' : [[aberration]] sphérique des faisceaux qui entrent obliquement dans un objectif ; ce défaut se traduit par la formation d'une traînée lumineuse dont l'aspect rappelle une queue de comète, d'où son nom.
* '''condenseur''' : lentille ou paire de lentilles plan-convexes utilisées pour concentrer la lumière d'une lampe de projecteur ou d'agrandisseur et la faire traverser le film négatif ou positif que l'on souhaite projeter ou agrandir. Ne pas confondre avec « condensateur », terme désignant un composant des circuits électriques.
* '''conservateur''' : produit protégeant de l'oxydation les substances réductrices constituant les révélateurs.
* '''contact-flash''' : prise électrique spéciale permettant de relier un appareil photographique avec un flash, afin de permettre le déclenchement de l'éclair ; cette liaison peut se faire par l'intermédiaire d'un cordon à brancher ou directement par un ou plusieurs contacts situés dans la griffe.
* '''correction de couleur''' : lorsque l'on utilise un film couleur avec un éclairage non adapté (par exemple, un film lumière du jour et un éclairage par des lampes à incandescence), il est nécessaire d'utiliser des filtres colorés de [[filtres modifiant la température de couleur|conversion ou de correction]].

== . D ==

* '''DAC''' : ''Digital Auto Correction'', système de traitement des fichiers RAW propre à [[Photographie/Fabricants/Hasselblad|Hasselblad]].

* '''DCF''' : ''Design rule for Caméra File system'', norme qui précise la structure et les noms des dossiers des cartes mémoires afin que celles-ci puissent communiquer de façon standardisée avec les divers équipements qui les reçoivent : appareils, lecteurs, etc.

* '''[[Photographie/Techniques particulières/Bascule et décentrement|décentrement]]''' : dispositif qui permet de décaler en translation l'axe optique de l'appareil par rapport à la perpendiculaire au centre du film ; ce mouvement permet de corriger les [[Photographie/Perspective/Photographie et perspective|perspectives]].

* '''[[Photographie/Photométrie/Les sources lumineuses#Les diodes électroluminescentes (DELs)|DEL]]''' : Diode ÉlectroLuminescente (LED en anglais).

* '''DNG''' : ''Digital NeGative'', format brut d'[[Adobe]].

* '''DO''' : ''Diffractive Optics'', mode de construction d'objectifs [[Photographie/Fabricants/Canon|Canon]] permettant une forte diminution du poids et de l'encombrement, comme le EF 400 mm f/4 DO IS USM. La série est très limitée, entre autres pour des raisons de coût.

* '''DPOF''' : ''Digital Print Order Format'', format destiné aux commandes de tirages numériques et qui permet de préciser les images à tirer, le nombre d'exemplaires, l'impression ou non de la date, ..., avec une imprimante compatible.

* '''DPS''' : ''Direct Print Standard'', norme relative aux systèmes permettant l'impression directe de photos sans passer par l'ordinateur. L'un des aboutissements est la norme PictBridge.

* '''DSLR''' : ''Digital Single Lens Reflex'', autrement dit réflex numérique mono-objectif.

== . E ==
* '''E6''' : procédé actuel de développement des films argentiques diapositives depuis 1976, a succédé aux procédés E3 et E4.'''
* '''EF''' : ''Electronic focus'', caractérise les objectifs [[Photographie/Fabricants/Canon|Canon]] qui comportent un moteur de mise au point intégré.
* '''EF-S''' : comme ci-dessus, sauf que ces objectifs sont destinés aux appareils munis de capteurs au format dit « APS ».
* '''ELD''' : ''Extraordinary Low Dispersion'', désigne un matériau optique dont la dispersion de la lumière est « anormalement » faible.
* '''ESP''' : ''Electro Selective Pattern'', mode de mesure de la lumière dans lequel l'appareil compare la luminosité de la zone centrale et des bords. S'il existe une différence importante, alors l'appareil propose ou impose une exposition qui ramènera la zone centrale vers le gris moyen pour en conserver les détails, sinon il utilise la mesure centrale pondérée.
* '''[[Photographie/Image numérique/Les métadonnées#Données EXIF|EXIF]]''' : ''Exchangeable Image File Format'', métadonnées inscrites dans les fichiers numériques, comportant les divers paramètres de la prise de vue et une vignette.

== . F ==
* '''FlashPix''' : format d'image utilisé par [[Photographie/Fabricants/Kodak|Eastman Kodak]], [[Photographie/Fabricants/Hewlett-Packard|Hewlett-Packard]], Live Picture et Microsoft pour ajouter des photos de haute qualité aux sites internet sans ralentir l'affichage à l'écran. Les fichiers FlashPix contiennent l'image originale intacte (non comprimée) et des copies dans diverses résolutions plus basses ; ils sont de ce fait plus volumineux que les fichiers JPEG. 
* '''[[Photographie/Surfaces sensibles/Formats de surfaces sensibles|formats]]''' des surfaces sensibles argentiques.

== . G ==
* '''grandissement''' : rapport entre les dimensions linéaires de l'image fournie par un système optique et celles correspondantes du sujet, comptées dans deux plans conjugués (plan de la surface sensible côté image et plan de mise au point côté sujet).

::: &lt;math&gt;g=\frac{dimensions \, de \, l'image}{dimensions \, du \, sujet} = \frac{distance \,(objectif \to surface \, sensible)}{distance \,(objectif \to sujet)}&lt;/math&gt;
: Le grandissement est par ailleurs proportionnel au tirage de l'objectif.

== . H ==

* '''''headshot''''' : en anglais, [[portrait]] où seule la tête est visible.

*  '''HIS''' : ''Hybrid Image Stabilization'', système de [[stabilisation]] introduit par [[Photographie/Fabricants/Canon|Canon]].

* '''HNSC''' : ''[[Photographie/Fabricants/Hasselblad|Hasselblad]] Natural Color Solution'', système de traitement des fichiers RAW propre à [[Photographie/Fabricants/Hasselblad|Hasselblad]].

* '''HSM''' : ''Hyper Sonic Motor'', système de mise au point par un moteur à ultrasons propre à la société [[Sigma]], analogue à la motorisation USM de [[Photographie/Fabricants/Canon|Canon]].

== . I ==
* '''IR''' : InfraRouge

== . J ==
* '''JPEG''' : Le Comité ''Joint Photographic Experts Group'', créé en 1986, a donné son nom à un format standard approprié à la transmission des images et des applications graphiques.

== . K ==

== . L ==
* '''L''' : ''Luxury'', les objectifs [[Photographie/Fabricants/Canon|Canon]] portant cette mention sont des optiques de haute qualité, destinées à des usages professionnels, avec une protection contre le ruissellement et une construction renforcée.
* '''LCD''' : ''Liquid Crystal Display'', ou affichage à cristaux liquides ('''ACL''' en français).
* '''[[Photographie/Photométrie/Les sources lumineuses#Les diodes électroluminescentes (DELs)|LED]]''' : ''Light Emitting Diode, ou Diode ÉlectroLuminescente (DEL en français).
* '''live view''' : ''visée en direct'', système de visée directe sur l'écran pour les appareils reflex numériques qui jusqu'en 2007 ne permettaient que la visée classique sur le dépoli.

== . M ==
* '''[[macrophotographie]]''' : domaine dans lequel, '''au moment de la prise de vue''', l'image formée par l'objectif est aussi grande ou plus grande que l'objet photographié.
* '''[[Photographie/Finition et présentation des photographies/Montage sous passe-partout|marie-louise]]''' : cache en bois, en carton toilé ou peint, etc., placé dans un autre cadre pour mettre en valeur un tableau, un dessin ou une photo.
* '''MC''' :
** ancienne monture [[Minolta]] 
** ''Multi-Coated'', l'abréviation signale qu'une surface optique a subi un traitement multicouche.
* '''MD''' : ancienne monture [[Minolta]]
* '''MEGA-OIS''' : ''Mega Optical Image Stabiliser'' (O.I.S.), système [[Panasonic]] de stabilisation d'images.
* '''[[Photographie/Image numérique/Les métadonnées|métadonnées]]''' : données servant à définir ou décrire d'autres données quel que soient leurs supports (papier, enregistrement magnétique, électronique, etc.) dans le but essentiel de les retrouver.
* '''[[Photographie/Filtres optiques/Filtres modifiant la température de couleur#Degrés réciproques (mired)|mired]]''' : ''Micro Reciprocal Degrees'', ou degrés réciproques, nombre caractérisant les filtres qui modifient la température de couleur.
* '''[[Photographie/Techniques scientifiques/Microphotographie|microphotographie]]''' : technique qui permet d'obtenir des images très petites d'objets macroscopiques ; ne pas confondre avec [[Photographie/Techniques scientifiques/Photomicrographie|photomicrographie]].
* '''MP-E''' : ''Macro Photo Extreme'', désignation [[Photographie/Fabricants/Canon|Canon]] pour un unique objectif macro de très haute qualité capable d'atteindre directement le rapport 5:1.
* '''MPEG''' : '' Moving Pictures Expert Group'', format d'enregistrement d'images animées et de sons, du nom du groupe d'experts qui supervisent ses caractéristiques de codage et de compression. C'est l'un des formats utilisés par les appareils photographiques numériques capables d'enregistrer des scènes animées.

== . N ==

== . O ==
* '''OIS''' : ''Optical Image Stabilizer'', système optique de stabilisation d'image.
* '''OPS''' : ''Optical Picture Stabilization'', système optique de stabilisation d'image.
* '''OS''' : ''Optical Stabilization'', système optique de stabilisation d'image de [[Sigma]].

== . P ==

* '''[[Photographie/Finition et présentation des photographies/Montage sous passe-partout|passe-partout]]''' : cadre avec ou sans glace, dont le fond s'ouvre à volonté pour recevoir les différents dessins ou photographies qu'on voudra successivement y placer.

* '''PC''' : ''Perspective Control'', lettres caractérisant certains objectifs spéciaux [[Nikon]] permettant les mouvements de [[Photographie/Techniques particulières/Bascule et décentrement|bascule et de décentrement]]

* '''[[Photographie/Techniques scientifiques/Photomicrographie|photomicrographie]]''' : technique qui permet d'obtenir des images de grande taille à partir d'objets très petits ; elle se pratique typiquement avec un microscope et ne doit pas être confondue avec la [[Photographie/Techniques scientifiques/Microphotographie|microphotographie]].

* '''PIM''' : ''Print Image Matching'', technologie [[Photographie/Fabricants/Epson|Epson]] pour améliorer l'impression des photos.

* '''pixel''' : abréviation de ''picture element'', c'est-à-dire élément d'image. Une définition élémentaire est donnée [[Photographie/Les premiers pas/Qu'est-ce qu'une image numérique ?|ici]].

* '''point and shoot''' : ''Viser et déclencher'', traduire simplement par ''appareil compact'' à fonctionnement essentiellement automatique et sans visée reflex.

* '''[[Photographie/Techniques scientifiques/Photographie rapprochée|proxiphotographie]]''' : encore appelé ''photographie rapprochée'' ou ''photographie de près'', ce domaine correspond à des rapports de grandissement relativement importants mais toujours tels que l'image obtenue '''au moment de la prise de vue''' est plus petite que le sujet photographié. À partir du rapport 1 commence le domaine de la [[macrophotographie]], où l'image est au moins aussi grande que l'objet.

* '''PZD''' : ''PieZo Drive'', nouveau type de motorisation ultrasonique développée par [[Tamron]] plus compacte que les versions traditionnelles.

== . Q ==

== . R ==
* '''[[Photographie/Surfaces sensibles/Formats de surfaces sensibles|Rapid]]''' : format de chargeur pour film 35 mm lancé par [[Photographie/Fabricants/Agfa|Agfa]].
* '''RAW''' : « Brut », format de fichier image numérique dont les données n'ont subi aucun traitement.
* '''remote control''' : commande à distance, par déclencheur souple, ultrasons, infrarouge, radio, etc.

== . S ==
* '''SAL''' : ''[[Sony]] A-mount Lens''.
* '''SAM''' : ''Smooth Autofocus Motor'', système autofocus de [[Sony]].
* '''SBC''' : ''Silicon Blue Cell'', cellule au silicium traité pour être sensible au bleu, se trouve dans les [[posemètre]]s.
* '''SD''' : ''Secure Digital'', format de cartes mémoires.
* '''SDM''' : ''Sonic Drive Motor'', motorisation ultrasonique des objectifs [[Pentax]]
* '''SEL''' ; '' Sony E-mount Lens''.
* '''''self timer''''' : retardateur
* '''SLD''' : ''Special Low Dispersion'', désigne un matériau optique à très faible [[dispersion de la lumière]]
* '''SLR''' : ''Single Lens Reflex'', appareil reflex mono-objectif.
* '''SmartMedia''' ou '''SM''' : format de carte mémoire.
* '''SP''' : ''Super Protect'', traitement des objectifs développé par [[Pentax]] pour repousser les salissures des objectifs telles que poussières, eau ou graisse.
* '''SSF''' : ''Super Shake-Free'', système de stabilisation des appareils [[Photographie/Fabricants/BenQ|BenQ]].
* '''sulfure de cadmium''' : composé chimique photosensible utilisé dans certains [[posemètre]]s et cellules intégrées aux appareils. 
* '''SWC''' : ''Subwavelength Structure Coating'', traitement antireflet des objectifs développé par [[Photographie/Fabricants/Canon|Canon]].
* '''SWD''' : ''Supersonic Wave Drive'', système de motorisation ultrasonique des objectifs propre à [[Olympus]].
* '''SWM''' : ''Silent Wave Motor'', système de motorisation ultrasonique [[Nikon]] permettant la mise au point autofocus des objectifs.

== . T ==
* '''TFT''' : ''Thin Film Transistor'', technologie utilisée pour la réalisation des écrans plats comme ceux qui équipent les ordinateurs, les téléviseurs et les appareils photo numériques.
* '''TIF''' : ''Tagged Image File'', format de fichier image numérique.
* '''tirage''' : 
:* le tirage d'un objectif est la distance ultra-nodale (comptée entre le point nodal d'émergence et le plan de l'image). Quand la mise au point est faite sur l'infini, le tirage est égal à la distance focale. Certains auteurs appellent tirage, à tort, la distance ultra-focale (comptée entre le foyer image et le plan de l'image) ou encore la distance entre la platine arrière de fixation de l'objectif et la surface sensible.

:* passage d'une image originale sur film ou sur support informatique à une épreuve sur papier, ou le résultat de cette opération.
* '''TLR''' : ''Twin Lens Reflex'', appareil reflex à deux objectifs.
* '''TS-E''' : ''Tilt and Shift Extreme'', désignation des objectifs [[Photographie/Fabricants/Canon|Canon]] à bascule et décentrement ; ces objectifs ne portent pas la mention « EF » car leur mise au point ne peut pas être automatisée.
* '''TTL''' : ''Through The Lens'', à travers l'objectif, désigne un mode de mesure de la lumière.

== . U ==
* '''USD''' : ''Ultrasonic Silent Drive'', système de mise au point propre à [[Tamron]]
* '''UV''' : UltraViolet

== . V ==
* '''VC''' : ''Vibration Compensation'', système de stabilisation propre aux objectifs [[Tamron]].
* '''[[vignettage]] :''' à grande ouverture la lumière est répartie inégalement et le phénomène se traduit par un assombrissement des zones périphériques de l'image, il est particulièrement sensible dans les angles. On écrit aussi, à tort, ''vignetage''.
* '''VR''' : ''Vibration Reduction'', système de stabilisation propre aux objectifs [[Nikon]].

== . W ==

* '''WB :''' ''White Balance'' ou Balance des blancs : c'est le réglage qui permet de corriger l'équilibre colorimétrique des images traitées dans l'appareil, en fonction de la source lumineuse.

== . X ==

== . Y ==

== . Z ==


* '''Zoom :''' objectif complexe qui, grâce à un groupe de lentilles mobiles, dispose d'une focale variable entre deux valeurs limites.

* '''Zoom numérique :''' c'est un simple agrandissement de l'image, parfois utile pour la visée, mais qui aboutit à n'enregistrer qu'une partie de l'image, avec évidemment une baisse de qualité d'autant plus grande que l'agrandissement a été plus important..</text>
      <sha1>qul6s0sux09g0nky7vuebkdfuhle0tg</sha1>
    </revision>
  </page>
  <page>
    <title>Livre de cuisine/Sauce cocktail</title>
    <ns>0</ns>
    <id>10459</id>
    <revision>
      <id>684285</id>
      <parentid>452832</parentid>
      <timestamp>2022-08-27T18:25:47Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1370" xml:space="preserve">{{livre de cuisine}}

La '''sauce cocktail''' est un dérivée de la {{i|sauce}} [[Livre de cuisine/Sauce mayonnaise|mayonnaise]] utilisé pour des entrées froides en nappage (avocats,asperges, tomates, céleris etc...)

== Ingrédient ==

Pour 6 personnes :
* 1 {{i'|œuf}} de gros calibre,
* 1 cuillère à soupe de {{i|moutarde}},
* 20 cl d'{{i'|huile de tournesol}},
* {{i|sel}},
* {{i|poivre}},
* 3 cl de {{i|cognac|Cognac}} ou {{i|whisky}},
* 2 gousses d'{{i'|ail|ails}},
* 1 petite boîte de concentré de {{i|tomate}},
* environ 15 cl d'eau.

== Préparation ==

* Faire une mayonnaise classique (''voir recette [[Livre de cuisine/Sauce mayonnaise|mayonnaise]]'')

*Incorporez-y le concentré de tomate et l'ail finement ciselé, battez au fouet jusqu'à que la mayonnaise ait une couleur rouge claire homogène 
*Rajoutez le Cognac ou le whisky
*Incorporez l'eau par dose de 5 cl fouettez vigoureusement et rajoutez de l'eau jusqu'à que la sauce ait un aspect &quot;nappée&quot; (elle doit rester solide mais coule si on la verse) 
* '''!! attention''' Selon la consistance de la mayonnaise, la quantité d'eau à mettre peut être plus ou moins importante (entre 5 et 15 cl), d'où son incorporation très progressive.

== Voir aussi ==
*[[w:mayonnaise|mayonnaise]] sur wikipédia.

[[Catégorie:Recettes végétariennes|Sauce cocktail]]
[[Catégorie:Sauces|Coktail]]</text>
      <sha1>o3etmio64xby7wopm67vvpxurqq8l7u</sha1>
    </revision>
    <revision>
      <id>684286</id>
      <parentid>684285</parentid>
      <timestamp>2022-08-27T18:26:18Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>/* Préparation */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1372" xml:space="preserve">{{livre de cuisine}}

La '''sauce cocktail''' est un dérivée de la {{i|sauce}} [[Livre de cuisine/Sauce mayonnaise|mayonnaise]] utilisé pour des entrées froides en nappage (avocats,asperges, tomates, céleris etc...)

== Ingrédient ==

Pour 6 personnes :
* 1 {{i'|œuf}} de gros calibre,
* 1 cuillère à soupe de {{i|moutarde}},
* 20 cl d'{{i'|huile de tournesol}},
* {{i|sel}},
* {{i|poivre}},
* 3 cl de {{i|cognac|Cognac}} ou {{i|whisky}},
* 2 gousses d'{{i'|ail|ails}},
* 1 petite boîte de concentré de {{i|tomate}},
* environ 15 cl d'eau.

== Préparation ==

# Faire une mayonnaise classique (''voir recette [[Livre de cuisine/Sauce mayonnaise|mayonnaise]]'')

# Incorporez-y le concentré de tomate et l'ail finement ciselé, battez au fouet jusqu'à que la mayonnaise ait une couleur rouge claire homogène 
# Rajoutez le Cognac ou le whisky
# Incorporez l'eau par dose de 5 cl fouettez vigoureusement et rajoutez de l'eau jusqu'à que la sauce ait un aspect &quot;nappée&quot; (elle doit rester solide mais coule si on la verse) 
# '''Attention !''' Selon la consistance de la mayonnaise, la quantité d'eau à mettre peut être plus ou moins importante (entre 5 et 15 cl), d'où son incorporation très progressive.

== Voir aussi ==
*[[w:mayonnaise|mayonnaise]] sur wikipédia.

[[Catégorie:Recettes végétariennes|Sauce cocktail]]
[[Catégorie:Sauces|Coktail]]</text>
      <sha1>99fta224s0lrdwhau6c57qxrr3zssru</sha1>
    </revision>
    <revision>
      <id>684287</id>
      <parentid>684286</parentid>
      <timestamp>2022-08-27T18:26:30Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1371" xml:space="preserve">{{livre de cuisine}}

La '''sauce cocktail''' est un dérivée de la {{i|sauce}} [[Livre de cuisine/Sauce mayonnaise|mayonnaise]] utilisé pour des entrées froides en nappage (avocats,asperges, tomates, céleris etc.).

== Ingrédient ==

Pour 6 personnes :
* 1 {{i'|œuf}} de gros calibre,
* 1 cuillère à soupe de {{i|moutarde}},
* 20 cl d'{{i'|huile de tournesol}},
* {{i|sel}},
* {{i|poivre}},
* 3 cl de {{i|cognac|Cognac}} ou {{i|whisky}},
* 2 gousses d'{{i'|ail|ails}},
* 1 petite boîte de concentré de {{i|tomate}},
* environ 15 cl d'eau.

== Préparation ==

# Faire une mayonnaise classique (''voir recette [[Livre de cuisine/Sauce mayonnaise|mayonnaise]]'')

# Incorporez-y le concentré de tomate et l'ail finement ciselé, battez au fouet jusqu'à que la mayonnaise ait une couleur rouge claire homogène 
# Rajoutez le Cognac ou le whisky
# Incorporez l'eau par dose de 5 cl fouettez vigoureusement et rajoutez de l'eau jusqu'à que la sauce ait un aspect &quot;nappée&quot; (elle doit rester solide mais coule si on la verse) 
# '''Attention !''' Selon la consistance de la mayonnaise, la quantité d'eau à mettre peut être plus ou moins importante (entre 5 et 15 cl), d'où son incorporation très progressive.

== Voir aussi ==
*[[w:mayonnaise|mayonnaise]] sur wikipédia.

[[Catégorie:Recettes végétariennes|Sauce cocktail]]
[[Catégorie:Sauces|Coktail]]</text>
      <sha1>4vnylb38wteqgt6dt37eycjeysniju6</sha1>
    </revision>
  </page>
  <page>
    <title>Néerlandais/Dans le secondaire/vocabulaire les couverts</title>
    <ns>0</ns>
    <id>11694</id>
    <revision>
      <id>684253</id>
      <parentid>568941</parentid>
      <timestamp>2022-08-27T17:58:01Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="659" xml:space="preserve">
{|class=&quot;wikitable&quot;
! Les couverts!!{{knop|bestek}} het bestek
|-
|Le couteau||{{knop|mes}} ''het {{nlwikt|mes}}''
|-
|La fourchette ||{{knop|vork}} ''de {{nlwikt|vork}}''
|-
|La cuillère||{{knop|lepel}} ''de {{nlwikt|lepel}}''
|-
! Les récipients !! {{knop|vaatwerk}} het vaatwerk
|-
|L'assiette ||{{knop|bord}} ''het {{nlwikt|bord}}''
|-
|Le plat||{{knop|schaal}} ''de {{nlwikt|schaal}}''
|-
|Le bol||{{knop|kom}} de {{nlwikt|kom}}
|-
|La bouteille ||{{knop|fles}}''de {{nlwikt|fles}}''
|-
|La tasse ||{{knop|kopje}} ''het {{nlwikt|kopje}}''
|-
|Le verre ||{{knop|glas}} ''het {{nlwikt|glas}}''
|}


[[Catégorie:Néerlandais dans le secondaire (livre)]]</text>
      <sha1>szdc8lxywees0qx7ngw1c3akm1syde5</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python</title>
    <ns>0</ns>
    <id>16094</id>
    <revision>
      <id>684227</id>
      <parentid>662330</parentid>
      <timestamp>2022-08-27T12:46:03Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="745" xml:space="preserve">{{Entête livre/début|
[[Fichier:Python-logo-notext.svg|center]]
''un livre appartenant à la série [[Programmation]]&lt;br/&gt;et à l'[[Accueil/Informatique|étagère Informatique]] de [[Accueil|Wikilivres]]''.}}

__NOTOC__
__NOEDITSECTION__
== Sommaire ==
Python est un langage de script multi-paradigme et multi-usage.
{{Version imprimable}}
{{version PDF}}
{{Moteur}}
{{Sous section|nom=Programmation Python/Sommaire|couleur=lightblue|couleurbord=darkblue|couleurfond=unset}}
{{Entête livre/fin|footer=1}}
&lt;noinclude&gt;
{{ÉtatDesWikilivres}}

== Voir aussi ==
* [[Python pour le calcul scientifique]]
* [[Mathématiques avec Python et Ruby]]
* {{WP|Liste de frameworks Python}}
* {{WP|Catégorie:Bot publié en Python}}
{{AutoCat}}
&lt;/noinclude&gt;</text>
      <sha1>cvl1driw6n9ls5bn1d4tgvjrzygt6p7</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Listes</title>
    <ns>0</ns>
    <id>16111</id>
    <revision>
      <id>684289</id>
      <parentid>676400</parentid>
      <timestamp>2022-08-27T18:27:49Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44287" xml:space="preserve">&lt;noinclude&gt;{{Python}}&lt;/noinclude&gt;

== Déclaration ==
Les listes sont des séquences, des collections ordonnées d'objets séparés par des virgules. On les déclare avec l'opérateur d'indiçage ([]) :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt; maListe = ['a','b','c']
&gt;&gt; maListe
['a','b','c']
&lt;/syntaxhighlight&gt;

== Lecture ==
Comme les caractères dans une chaîne, les objets placés dans une liste sont rendus accessibles par l'intermédiaire d'un ''index'' (un nombre qui indique l'emplacement de l'objet dans la séquence, à partir de zéro). De plus, le ''slicing'' (« découpage en tranches ») permet aussi de dégager une sous-liste en précisant deux index correspondant aux bornes de la plage.

Une sortie indicée donne :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt; maListe[0]
'a'

&gt;&gt; maListe[-1]
'c'
&lt;/syntaxhighlight&gt;

Une séquence donne par slicing :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt; maListe[0:2]
['a','b']

&gt;&gt; maListe[1:]
['b','c']
&lt;/syntaxhighlight&gt;

=== Types ===
Les éléments qui constituent une liste peuvent être de types variés :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
&gt;&gt;&gt; print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
&lt;/syntaxhighlight&gt;

Dans cet exemple, en effet, les premiers éléments sont des chaînes de caractères, puis il y a un entier et un réel. À cet égard, le concept de liste est donc différent des tableaux (''array'') que l'on rencontre les langages de programmation de {{wt|bas niveau}}, où tous les éléments doivent être du même type.

=== Recherche ===
Vous pouvez aisément déterminer si un élément fait partie d'une liste à l'aide de l'instruction &lt;code&gt;in&lt;/code&gt; :
&lt;syntaxhighlight lang=python&gt;
 print(&quot;a&quot; in [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])      # True
 print(not &quot;a&quot; in [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])  # False
&lt;/syntaxhighlight&gt;

Si l'emplacement de l'élément importe dans la liste :
&lt;syntaxhighlight lang=python&gt;
 print [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;].index(&quot;a&quot;) == 0 # True
 print [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;].index(&quot;z&quot;)      # ValueError
&lt;/syntaxhighlight&gt;

== Modification ==
=== Affectation ===
À la différence de ce qui se passe pour les chaînes, qui constituent un type de données non-modifiables, il est possible de changer les éléments individuels d'une liste :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
&gt;&gt;&gt; jour[5] = jour[5] + 1016
&gt;&gt;&gt; print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 1492, 3.142]
&lt;/syntaxhighlight&gt;

Les exemples ci-dessus devraient attirer votre attention sur le fait qu'une ''tranche'' découpée dans une liste est toujours elle-même une liste (même s'il s'agit d'une tranche qui ne contient qu'un seul élément), alors qu'un élément isolé peut contenir n'importe quel type de donnée.

Exemple en deux dimensions :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', ['samedi matin', 'samedi après-midi', 'samedi soir'], 'dimanche']
&gt;&gt;&gt; jour[5][0] = &quot;samedi midi&quot;
&gt;&gt;&gt; jour
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', ['samedi midi', 'samedi après-midi', 'samedi soir'], 'dimanche']
&lt;/syntaxhighlight&gt;
Ainsi, dans l'exemple ci-dessus on remplace le premier élément d'une liste (n° 0), qui est elle-même l'élément n° 5 d'une autre liste.

=== Opérations ===
On peut appliquer aux listes les opérateurs + (concaténation) et * (multiplication) :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; fruits = ['orange','citron']
&gt;&gt;&gt; legumes = ['poireau','oignon','tomate']
&gt;&gt;&gt; fruits + legumes
['orange', 'citron', 'poireau', 'oignon', 'tomate']
&gt;&gt;&gt; fruits * 3
['orange', 'citron', 'orange', 'citron', 'orange', 'citron']
&lt;/syntaxhighlight&gt;

L'opérateur * est particulièrement utile pour créer une liste de &quot;n&quot; éléments identiques :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; sept_zeros = [0]*7
&gt;&gt;&gt; sept_zeros
[0, 0, 0, 0, 0, 0, 0]
&lt;/syntaxhighlight&gt;

=== Techniques de slicing avancées pour modifier une liste ===
==== Insertion ====
Insertion d'un ou plusieurs éléments n'importe où dans une liste :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; mots = ['jambon', 'fromage', 'confiture', 'chocolat']
&gt;&gt;&gt; mots[2:2] = [&quot;miel&quot;]
&gt;&gt;&gt; mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat']
&gt;&gt;&gt; mots[5:5] = ['saucisson', 'ketchup']
&gt;&gt;&gt; mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat', 'saucisson', 'ketchup']
&lt;/syntaxhighlight&gt;

Pour utiliser cette technique, vous devez prendre en compte les particularités suivantes :

* Si vous utilisez l'opérateur &lt;code&gt;[ ]&lt;/code&gt; à la gauche du signe égale pour effectuer une insertion ou une suppression d'élément(s) dans une liste, vous devez obligatoirement y indiquer une « tranche » dans la liste cible (c'est-à-dire deux index réunis par le symbole &quot;:&quot;), et non un élément isolé dans cette liste.

* L'élément que vous fournissez à la droite du signe égale doit lui-même être une liste. Si vous n'insérez qu'un seul élément, il vous faut donc le présenter entre crochets pour le transformer d'abord en une liste d'un seul élément. Notez bien que l'élément &lt;code&gt;mots[1]&lt;/code&gt; n'est pas une liste (c'est la chaîne &lt;code&gt;fromage&lt;/code&gt;), alors que l'élément &lt;code&gt;mots[1:3]&lt;/code&gt; en est une.

==== Suppression ====
Suppression / remplacement d'éléments :
&lt;syntaxhighlight lang=python line&gt;
&gt;&gt;&gt; mots[2:5] = []                       # [] désigne une liste vide
&gt;&gt;&gt; mots
['jambon','fromage','saucisson', 'ketchup']
&gt;&gt;&gt; mots[1:3] = ['salade']
&gt;&gt;&gt; mots
['jambon', 'salade', 'ketchup']
&gt;&gt;&gt; mots[1:] = ['mayonnaise', 'poulet', 'tomate']
&gt;&gt;&gt; mots
['jambon', 'mayonnaise', 'poulet', 'tomate']
&lt;/syntaxhighlight&gt;
 
* À la première ligne de cet exemple, nous remplaçons la tranche [2:5] par une liste vide, ce qui correspond à un effacement.

* À la quatrième ligne, nous remplaçons une tranche par un seul élément. (Notez encore une fois que cet élément doit lui-même être « présenté » comme une liste).

* À la 7e ligne, nous remplaçons une tranche de deux éléments par une autre qui en comporte 3.

==== Différence ====
Pour obtenir la différence entre deux listes :
&lt;syntaxhighlight lang=python&gt;
a = ['jambon','fromage','saucisson', 'ketchup']
b = ['jambon', 'mayonnaise', 'poulet', 'tomate']
print([item for item in a if item not in b])
# ['fromage', 'saucisson', 'ketchup']
&lt;/syntaxhighlight&gt;

==== Intersection ====
Pour l'intersection entre deux listes (en préservant l'ordre des éléments y compris leurs doublons), on applique la différence de la différence :
&lt;syntaxhighlight lang=python&gt;
a = ['jambon','fromage','saucisson', 'ketchup']
b = ['jambon', 'mayonnaise', 'poulet', 'tomate']
dif = [item for item in a if item not in b]
print [item for item in a if item not in dif]
# ['jambon']
&lt;/syntaxhighlight&gt;

=== Copie ===

Considérons que vous disposez d'une liste fable que vous souhaitez recopier dans une nouvelle variable que vous appellerez phrase. La première idée qui vous viendra à l'esprit sera certainement d'écrire une simple affectation telle que :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; phrase = fable
&lt;/syntaxhighlight&gt;

En procédant ainsi, sachez que vous ne créez pas une véritable copie. À la suite de cette instruction, il n'existe toujours qu'une seule liste dans la mémoire de l'ordinateur. Ce que vous avez créé est seulement ''une nouvelle référence vers cette liste''. Essayez par exemple :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; fable = ['Je','plie','mais','ne','romps','point']
&gt;&gt;&gt; phrase = fable
&gt;&gt;&gt; fable[4] ='casse'
&gt;&gt;&gt; phrase
['Je', 'plie', 'mais', 'ne', 'casse', 'point']
&lt;/syntaxhighlight&gt;

Si la variable phrase contenait une véritable copie de la liste, cette copie serait indépendante de l'original et ne devrait donc pas pouvoir être modifiée par une instruction telle que celle de la troisième ligne, qui s'applique à la variable &lt;code&gt;fable&lt;/code&gt;. Vous pouvez encore expérimenter d'autres modifications, soit au contenu de &lt;code&gt;fable&lt;/code&gt;, soit au contenu de phrase. Dans tous les cas, vous constaterez que les modifications de l'une sont répercutées dans l'autre, et vice-versa.

En fait, les noms &lt;code&gt;fable&lt;/code&gt; et &lt;code&gt;phrase&lt;/code&gt; désignent tous deux un seul et même objet en mémoire. Pour décrire cette situation, les informaticiens diront que le nom phrase est un ''alias'' du nom &lt;code&gt;fable&lt;/code&gt;.

[[Image:Apprendre à programmer avec Python 32.png|center|500px|Schéma de la copie d'une liste.]]

Nous verrons plus tard l'utilité des ''alias''. Pour l'instant, nous voudrions disposer d'une technique pour effectuer une véritable copie d'une liste. Avec les notions vues précédemment, vous devriez pouvoir en trouver une par vous-même.  

{{remarque|Python vous autorise à « étendre » une longue instruction sur plusieurs lignes, si vous continuez à encoder quelque chose qui est délimité par une paire de parenthèses, de crochets ou d'accolades. Vous pouvez traiter ainsi des expressions parenthésées, ou encore la définition de longues listes, de grands tuples ou de grands dictionnaires. Le niveau d'indentation n'a pas d'importance : l'interpréteur détecte la fin de l'instruction, là où la paire syntaxique est refermée.}}

Cette fonctionnalité vous permet d'améliorer la lisibilité de vos programmes. Exemple :

&lt;syntaxhighlight lang=python&gt;
couleurs = ['noir', 'brun', 'rouge',
            'orange', 'jaune', 'vert',
            'bleu', 'violet', 'gris', 'blanc']
&lt;/syntaxhighlight&gt;


== Méthodes ==

Sous Python, les listes sont des objets à part entière, et vous pouvez donc leur appliquer un certain nombre de ''méthodes'' particulièrement efficaces, après l'opérateur &quot;.&quot; :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; nombres = [17, 38, 10, 25, 72]

&gt;&gt;&gt; nombres.sort()                 # trier la liste
&gt;&gt;&gt; nombres
[10, 17, 25, 38, 72]

&gt;&gt;&gt; nombres.append(12)             # ajouter un élément à la fin
&gt;&gt;&gt; nombres
[10, 17, 25, 38, 72, 12]

&gt;&gt;&gt; nombres.reverse()              # inverser l'ordre des éléments
&gt;&gt;&gt; nombres
[12, 72, 38, 25, 17, 10]

&gt;&gt;&gt; nombres.index(17)              # retrouver l'index d'un élément
4

&gt;&gt;&gt; nombres.remove(38)             # enlever (effacer) un élément
&gt;&gt;&gt; nombres
[12, 72, 25, 17, 10]
&lt;/syntaxhighlight&gt;

=== ''append'' ===
&lt;code&gt;append()&lt;/code&gt; (ajouter) : l'exemple suivant qui fait appel à la méthode &quot;append&quot; de l'objet &quot;liste&quot; (déclarée vide) illustre ce concept.

Il s'agit de remplir la hotte du Père Noël.
&lt;syntaxhighlight lang=python&gt;
 #!/usr/bin/python
 # -*- coding: iso8859-1 -*-
 
 # on prépare une liste encore vide
 cadeaux = []
 
 # on va ajouter des éléments à la liste
 unCadeau = &quot;&quot;
 
 # la suite des éléments à introduire dans la liste est définie par l'utilisateur
 # lorsqu'il a terminé, l'utilisateur indique le mot &quot;fin&quot; qui ne sera pas introduit dans la liste
 while unCadeau &lt;&gt; &quot;fin&quot;:
 	unCadeau = raw_input (&quot;Père Noël, je voudrais que tu m'apportes &quot;)
        # si l'utilisateur n'a pas frappé &quot;fin&quot;, le mot est ajouté à la liste
 	if unCadeau &lt;&gt; &quot;fin&quot;:
 		cadeaux.append(unCadeau)
 
 # finalement, on écrit la suite des éléments introduits dans la liste
 for chaqueCadeau in cadeaux:
 	print chaqueCadeau
&lt;/syntaxhighlight&gt;

=== ''split'' ===
&lt;code&gt;split()&lt;/code&gt; : convertit une chaîne en une liste de sous-chaînes. On peut choisir le caractère séparateur en le fournissant comme argument, sinon c'est un espace, par défaut.
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; chaine =&quot;Votez pour moi&quot;
&gt;&gt;&gt; tableau = chaine.split()
&gt;&gt;&gt; print tableau
['Votez', 'pour', 'moi']

&gt;&gt;&gt; chaine = &quot;Cet exemple, parmi d'autres, peut encore servir&quot;
&gt;&gt;&gt; chaine.split(&quot;,&quot;)
['Cet exemple', &quot; parmi d'autres&quot;, ' peut encore servir']
&lt;/syntaxhighlight&gt;

=== ''join'' ===
&lt;code&gt;join(liste)&lt;/code&gt; : rassemble une liste de chaînes en une seule (Cette méthode fait donc l'inverse de la précédente). Attention : la chaîne à laquelle on applique cette méthode est celle qui servira de séparateur (un ou plusieurs caractères) ; l'argument transmis est la liste des chaînes à rassembler.
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; tableau = [&quot;Salut&quot;, &quot;les&quot;, &quot;copains&quot;]
&gt;&gt;&gt; print  &quot; &quot;.join(tableau)
Salut les copains
&gt;&gt;&gt; print  &quot;___&quot;.join(tableau)
Salut___les___copains
&lt;/syntaxhighlight&gt;

=== ''pop'' ===
&lt;code&gt;pop(i)&lt;/code&gt; retire et renvoie l'élément de la liste d'index ''i''. Si ''i'' est vide, il traite le dernier élément.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; list = [1, 2, 3, 4]

&gt;&gt;&gt; print(list.pop(0))
1
&gt;&gt;&gt; list
[2, 3, 4]

&gt;&gt;&gt; print(list.pop())
4
&gt;&gt;&gt;list
[2, 3]
&lt;/syntaxhighlight&gt;


== Fonctions ==
=== ''len'' ===
La ''fonction intégrée'' &lt;code&gt;len()&lt;/code&gt;, que nous avons déjà rencontrée à propos des chaînes, s'applique aussi aux listes. Elle renvoie le nombre d'éléments présents dans la liste :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; len(jour)
7
&lt;/syntaxhighlight&gt;

Supposons par exemple que vous voulez créer une liste &lt;code&gt;B&lt;/code&gt; qui contienne le même nombre d'éléments qu'une autre liste &lt;code&gt;A&lt;/code&gt;. Vous pouvez obtenir ce résultat de différentes manières, mais l'une des plus simples consistera à effectuer : &lt;code&gt;B = [0]*len(A)&lt;/code&gt;.

=== ''del'' ===
Une autre ''fonction intégrée'' permet de supprimer d'une liste un élément ou plusieurs éléments quelconques à partir de leurs index. Il s'agit de la fonction &lt;code&gt;del()&lt;/code&gt; :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]

&gt;&gt;&gt; del(jour[5:7])
&gt;&gt;&gt; print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']

&gt;&gt;&gt; del(jour[0])
&gt;&gt;&gt; print(jour)
['mardi', 'mercredi', 'jeudi', 'vendredi']
&lt;/syntaxhighlight&gt;

{{remarque|notez bien la différence entre la méthode &lt;code&gt;remove()&lt;/code&gt; et la fonction &lt;code&gt;del()&lt;/code&gt; : &lt;code&gt;del&lt;/code&gt; travaille avec un indice ou une tranche d'indices, tandis que &lt;code&gt;remove()&lt;/code&gt; recherche ''une valeur'' (si plusieurs éléments de la liste possèdent la même valeur, seul le premier est effacé).}}

=== ''min'' et ''max'' ===
* &lt;code&gt;min(liste)&lt;/code&gt; : minimum d'une liste (élément ayant la plus petite valeur).
* &lt;code&gt;max(liste)&lt;/code&gt; : maximum d'une liste.

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']

&gt;&gt;&gt; min(jour)
'jeudi'

&gt;&gt;&gt; max(jour)
'vendredi'
&lt;/syntaxhighlight&gt;

=== ''range'' ===
Si vous devez manipuler des séquences de nombres, vous pouvez les créer très aisément à l'aide de cette fonction :
&lt;pre&gt;
&gt;&gt;&gt; range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
&lt;/pre&gt;
Sous python 3.6:
print(list(range(10)))
La fonction &lt;code&gt;range()&lt;/code&gt; génère une liste de nombres entiers de valeurs croissantes. Si vous appelez &lt;code&gt;range()&lt;/code&gt; avec un seul argument, la liste contiendra un nombre de valeurs égal à l'argument fourni, mais en commençant à partir de zéro (''c'est-à-dire que &lt;code&gt;range(n)&lt;/code&gt; génère les nombres de 0 à n-1'').

Notez bien que l'argument fourni n'est jamais dans la liste générée.

On peut aussi utiliser &lt;code&gt;range()&lt;/code&gt; avec deux, ou même trois arguments séparés par des virgules, afin de générer des séquences de nombres plus spécifiques :

&lt;pre&gt;
&gt;&gt;&gt; range(5,13)
[5, 6, 7, 8, 9, 10, 11, 12]
&gt;&gt;&gt; range(3,16,3)
[3, 6, 9, 12, 15]
&lt;/pre&gt;

Si vous avez du mal à assimiler l'exemple ci-dessus, considérez que &lt;code&gt;range()&lt;/code&gt; attend toujours trois arguments, que l'on pourrait intituler &lt;code&gt;FROM&lt;/code&gt;, &lt;code&gt;TO&lt;/code&gt; et &lt;code&gt;STEP&lt;/code&gt;. &lt;code&gt;FROM&lt;/code&gt; est la première valeur à générer, &lt;code&gt;TO&lt;/code&gt; est la dernière (ou plutôt la dernière + un), et &lt;code&gt;STEP&lt;/code&gt; le « pas » à sauter pour passer d'une valeur à la suivante. S'ils ne sont pas fournis, les paramètres &lt;code&gt;FROM&lt;/code&gt; et &lt;code&gt;STEP&lt;/code&gt; prennent leurs valeurs par défaut, qui sont respectivement 0 et 1.

=== Parcours d'une liste à l'aide de for, range() et len() ===

L'instruction &lt;code&gt;for&lt;/code&gt; est l'instruction idéale pour parcourir une liste :

&lt;pre&gt;
&gt;&gt;&gt; prov = ['La','raison','du','plus','fort','est','toujours','la','meilleure']
&gt;&gt;&gt; for mot in prov:
       print mot,
La raison du plus fort est toujours la meilleure
&lt;/pre&gt;

Il est très pratique de combiner les fonctions &lt;code&gt;range()&lt;/code&gt; et &lt;code&gt;len()&lt;/code&gt; pour obtenir automatiquement tous les indices d'une séquence (liste ou chaîne). Exemple :

&lt;syntaxhighlight lang=python&gt;
fable = ['Maître','Corbeau','sur','un','arbre','perché']
for index in range(len(fable)):
    print index, fable[index]
&lt;/syntaxhighlight&gt;

Mais il existe également une syntaxe adaptée à cela :

&lt;syntaxhighlight lang=python&gt;
for (cle, valeur) in enumerate(fable):
    print(cle, valeur)
&lt;/syntaxhighlight&gt;

L'exécution de ce script donne le résultat :
&lt;pre&gt;
0 Maître
1 Corbeau
2 sur
3 un
4 arbre
5 perché
&lt;/pre&gt;

Tableau à trois lignes :
&lt;syntaxhighlight lang=python&gt;
monTableau = range(1, 5)
monTableau[1] = u'ligne 1'
monTableau[2] = u'ligne 2'
monTableau[3] = u'ligne 3'

for ligne in range(1, 4):
    print(monTableau[ligne])
&lt;/syntaxhighlight&gt;

Tableau à deux dimensions :
&lt;syntaxhighlight lang=python&gt;
ligne = 3
colonne = 2
monTableau = [[0] * (colonne+1) for _ in range(ligne+1)]
monTableau[1][1] = u'1.1'
monTableau[1][2] = u'1.2'
monTableau[2][1] = u'2.1'
monTableau[2][2] = u'2.2'
monTableau[3][1] = u'3.1'
monTableau[3][2] = u'3.2'

for l in range(1, ligne + 1):
    for c in range(1, colonne + 1):
        print(monTableau[l][c])
&lt;/syntaxhighlight&gt;

==== Une conséquence du typage dynamique ====

Le type de la variable utilisée avec l'instruction &quot;for&quot; est redéfini continuellement au fur et à mesure du parcours : même si les éléments d'une liste sont de types différents, on peut parcourir cette liste à l'aide de &quot;for&quot; sans qu'il ne s'ensuive une erreur, car le type de la variable de parcours s'adapte automatiquement à celui de l'élément en cours de lecture. Exemple :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; divers = [3, 17.25, [5, 'Jean'], 'Linux is not Windoze']
&gt;&gt;&gt; for item in divers:
        print item, type(item)
&lt;/syntaxhighlight&gt;
 3 &lt;type 'int'&gt;
 17.25 &lt;type 'float'&gt;
 [5, 'Jean'] &lt;type 'list'&gt;
 Linux is not Windoze &lt;type 'str'&gt;

=== ''random'' ===

La plupart des programmes d'ordinateur font exactement la même chose chaque fois qu'on les exécute. De tels programmes sont dits ''déterministes''. Le déterminisme est certainement une bonne chose : nous voulons évidemment qu'une même série de calculs appliquée aux mêmes données initiales aboutisse toujours au même résultat.  Pour certaines applications, cependant, nous pouvons souhaiter que l'ordinateur soit imprévisible. Le cas des jeux constitue un exemple évident, mais il en existe bien d'autres.

Contrairement aux apparences, il n'est pas facile du tout d'écrire un algorithme qui soit réellement non-déterministe (c'est-à-dire qui produise un résultat totalement imprévisible). Il existe cependant des techniques mathématiques permettant de ''simuler'' plus ou moins bien l'effet du hasard.  Des livres entiers ont été écrits sur les moyens de produire ainsi un hasard « de bonne qualité ». Nous n'allons évidemment pas développer ici une telle question, mais rien ne vous empêche de consulter à ce sujet votre professeur de mathématiques.

Dans son module ''random'', Python propose toute une série de fonctions permettant de générer des nombres aléatoires qui suivent différentes distributions mathématiques. Nous n'examinerons ici que quelques-unes d'entre elles. Veuillez consulter la documentation en ligne pour découvrir les autres. Vous pouvez importer toutes les fonctions du module par : 

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; from random import *
&lt;/syntaxhighlight&gt;

Pour créer une liste de nombres réels aléatoires, de valeur comprise entre zéro et un :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; s = [0]*tailleListe
    for i in range(tailleListe):
        s[i] = random()
    print(s)
&lt;/syntaxhighlight&gt;

Vous pouvez constater que nous avons pris le parti de construire d'abord une liste de zéros de taille n, et ensuite de remplacer les zéros par des nombres aléatoires.

{{Exercices}}
# Réécrivez la fonction &lt;code&gt;list_aleat()&lt;/code&gt; ci-dessus, en utilisant la méthode &lt;code&gt;append()&lt;/code&gt; pour construire la liste petit à petit à partir d'une liste vide (au lieu de remplacer les zéros d'une liste préexistante comme nous l'avons fait).
# Écrivez une fonction &lt;code&gt;imprime_liste()&lt;/code&gt; qui permette d'afficher ligne par ligne tous les éléments contenus dans une liste de taille quelconque. Le nom de la liste sera fourni en argument. Utilisez cette fonction pour imprimer la liste de nombres aléatoires générés par la fonction &lt;code&gt;list_aleat()&lt;/code&gt;. Ainsi par exemple, l'instruction &lt;code&gt;imprime_liste(liste_aleat(8))&lt;/code&gt; devra afficher une colonne de 8 nombres réels aléatoires.
{{solution}}
#Réfléchissez !
#Réfléchissez !
{{fin}}

Les nombres ainsi générés sont-ils vraiment aléatoires ? C'est difficile à dire. Si nous ne tirons qu'un petit nombre de valeurs, nous ne pouvons rien vérifier. Par contre, si nous utilisons un grand nombre de fois la fonction &lt;code&gt;random()&lt;/code&gt;, nous nous attendons à ce que la moitié des valeurs produites soient plus grandes que 0,5 (et l'autre moitié plus petites).

Affinons ce raisonnement.  Les valeurs tirées sont toujours dans l'intervalle 0-1. Partageons cet intervalle en 4 fractions égales : de 0 à 0,25 , de 0,25 à 0,5 , de 0,5 à 0,75 , et de 0,75 à 1. Si nous tirons un grand nombre de valeurs au hasard, nous nous attendons à ce qu'il y en ait autant qui se situent dans chacune de nos 4 fractions.  Et nous pouvons généraliser ce raisonnement à un nombre quelconque de fractions, du moment qu'elles soient égales.

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Vous allez écrire un programme destiné à vérifier le fonctionnement du générateur de nombres aléatoires de Python en appliquant la théorie exposée ci-dessus. Votre programme devra donc :

a) Demander à l'utilisateur le nombre de valeurs à tirer au hasard à l'aide de la fonction &lt;code&gt;random()&lt;/code&gt;. Il serait intéressant que le programme propose un nombre par défaut (1000 par exemple).

b) Demander à l'utilisateur en combien de fractions il souhaite partager l'intervalle des valeurs possibles (c'est-à-dire l'intervalle de 0 à 1). Ici aussi, il faudrait proposer un nombre de par défaut (5 fractions, par exemple). Vous pouvez également limiter le choix de l'utilisateur à un nombre compris entre 2 et le 1/10e du nombre de valeurs tirées au hasard.

c) Construire une liste de N compteurs (N étant le nombre de fractions souhaitées). Chacun d'eux  sera évidemment initialisé à zéro.

d) Tirer au hasard toutes les valeurs demandées, à l'aide de la fonction &lt;code&gt;random()&lt;/code&gt;, et mémoriser ces valeurs dans une liste.

e) Mettre en œuvre un parcours de la liste des valeurs tirées au hasard (boucle), et effectuer un test sur chacune d'elles pour déterminer dans quelle fraction de l'intervalle 0-1 elle se situe. Incrémenter de une unité le compteur correspondant.

f) Lorsque c'est terminé, afficher l'état de chacun des compteurs.
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Test du générateur de nombres aléatoires :
from random import random           # tire au hasard un réel entre 0 et 1

n = raw_input(&quot;Nombre de valeurs à tirer au hasard (défaut = 1000) : &quot;)
if n == &quot;&quot;:
    nVal =1000
else:
    nVal = int(n)

n = raw_input(&quot;Nombre de fractions dans l'intervalle 0-1 (entre 2 et &quot;
              + str(nVal/10) + &quot;, défaut =5) : &quot;)
if n == &quot;&quot;:
    nFra =5
else:
    nFra = int(n)

if nFra &lt; 2:
    nFra =2
elif nFra &gt; nVal/10:
    nFra = nVal/10

print &quot;Tirage au sort des&quot;, nVal, &quot;valeurs ...&quot;
listVal = [0]*nVal                      # créer une liste de zéros
for i in range(nVal):                   # puis modifier chaque élément
    listVal[i] = random()

print &quot;Comptage des valeurs dans chacune des&quot;, nFra, &quot;fractions ...&quot;
listCompt = [0]*nFra                    # créer une liste de compteurs

# parcourir la liste des valeurs :
for valeur in listVal:
    # trouver l'index de la fraction qui contient la valeur :    
    index = int(valeur*nFra)
    # incrémenter le compteur correspondant :
    listCompt[index] = listCompt[index] +1

# afficher l'état des compteurs :
for compt in listCompt:
    print compt,
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

==== Exemple de résultats affichés par un programme de ce type ====

&lt;pre&gt;
Nombre de valeurs à tirer au hasard (défaut = 1000) : 100
Nombre de fractions dans l'intervalle 0-1 (entre 2 et 10, défaut =5) : 5
Tirage au sort des 100 valeurs ...
Comptage des valeurs dans chacune des 5 fractions ...
11 30 25 14 20 
Nombre de valeurs à tirer au hasard (défaut = 1000) : 10000
Nombre de fractions dans l'intervalle 0-1 (entre 2 et 1000, défaut =5) : 5
Tirage au sort des 10000 valeurs ...
Comptage des valeurs dans chacune des 5 fractions ...
1970 1972 2061 1935 2062
&lt;/pre&gt;

Une bonne approche de ce genre de problème consiste à essayer d'imaginer quelles fonctions simples vous pourriez écrire pour résoudre l'une ou l'autre partie du problème, puis de les utiliser dans un ensemble plus vaste.

Par exemple, vous pourriez chercher à définir d'abord une fonction &lt;code&gt;numeroFraction()&lt;/code&gt; qui servirait à déterminer dans quelle fraction de l'intervalle 0-1 une valeur tirée se situe. Cette fonction attendrait deux arguments (la valeur tirée, le nombre de fractions choisi par l'utilisateur) et fournirait en retour l'index du compteur à incrémenter (c'est-à-dire le n° de la fraction correspondante). Il existe peut-être un raisonnement mathématique simple qui permette de déterminer l'index de la fraction à partir de ces deux arguments. Pensez notamment à la fonction intégrée &lt;code&gt;int()&lt;/code&gt;, qui permet de convertir un nombre réel en nombre entier en éliminant sa partie décimale.

Si vous ne trouvez pas, une autre réflexion intéressante serait peut-être de construire d'abord une liste contenant les valeurs « pivots » qui délimitent les fractions retenues (par exemple 0 – 0,25 – 0,5 – 0,75 - 1 dans le cas de 4 fractions). La connaissance de ces valeurs faciliterait peut-être l'écriture de la fonction &lt;code&gt;numeroFraction()&lt;/code&gt; que nous souhaitons mettre au point.

Si vous disposez d'un temps suffisant, vous pouvez aussi réaliser une version graphique de ce programme, qui présentera les résultats sous la forme d'un histogramme (diagramme « en bâtons »).

==== Tirage au hasard de nombres entiers ====

Lorsque vous développerez des projets personnels, il vous arrivera fréquemment de souhaiter pouvoir disposer d'une fonction qui permette de tirer au hasard un nombre entier entre certaines limites. Par exemple, si vous voulez écrire un programme de jeu dans lequel des cartes à jouer sont tirées au hasard (à partir d'un jeu ordinaire de 52 cartes), vous aurez certainement l'utilité d'une fonction capable de tirer au hasard un nombre entier compris entre 1 et 52.

Vous pouvez pour ce faire utiliser la fonction &lt;code&gt;randrange()&lt;/code&gt; du module &lt;code&gt;random&lt;/code&gt;.

Cette fonction peut être utilisée avec 1, 2 ou 3 arguments.

Avec un seul argument, elle renvoie un entier compris entre zéro et la valeur de l'argument diminué d'une unité. Par exemple, &lt;code&gt;randrange(6)&lt;/code&gt; renvoie un nombre compris entre 0 et 5.

Avec deux arguments, le nombre renvoyé est compris entre la valeur du premier argument et la valeur du second argument diminué d'une unité. Par exemple, &lt;code&gt;randrange(2, 8)&lt;/code&gt; renvoie un nombre compris entre 2 et 7.

Si l'on ajoute un troisième argument, celui-ci indique que le nombre tiré au hasard doit faire partie d'une série limitée d'entiers, séparés les uns des autres par un certain intervalle, défini lui-même par ce troisième argument. Par exemple, &lt;code&gt;randrange(3, 13, 3)&lt;/code&gt; renverra un des nombres de la série 3, 6, 9, 12 :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; for i in range(15):
        print random.randrange(3,13,3),

3 12 6 9 6 6 12 6 3 6 9 3 6 12 12
&lt;/syntaxhighlight&gt;

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Écrivez un script qui tire au hasard des cartes à jouer. Le nom de la carte tirée doit être correctement présenté, « en clair ». Le programme affichera par exemple :

&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;Dix de Trèfle&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;As de Carreau&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;Huit de Pique&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;etc ...&lt;/code&gt;&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Tirage de cartes
from random import randrange

couleurs = ['Pique', 'Trèfle', 'Carreau', 'Cœur']
valeurs = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'valet', 'dame', 'roi', 'as']

# Construction de la liste des 52 cartes :
carte =[]
for coul in couleurs:
     for val in valeurs:
          carte.append(&quot;%s de %s&quot; % (str(val), coul))

# Tirage au hasard :
while 1:
     k = raw_input(&quot;Frappez &lt;c&gt; pour tirer une carte, &lt;Enter&gt; pour terminer &quot;) 
     if k ==&quot;&quot;:
          break
     r = randrange(52)
     print carte[r]
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

=== map ===
Permet d'appliquer une fonction à toutes les entrées d'une liste. Par exemple pour les ''trimer'' :
&lt;syntaxhighlight lang=python&gt;
l = [' ma super ligne 1\n', ' ma super ligne 2\n']
l = map(str.strip, l)
print l
# ['ma super ligne 1', 'ma super ligne 2']
&lt;/syntaxhighlight&gt;

== Exercices ==
{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Soient les listes suivantes :

&lt;code&gt;t1 = [31,28,31,30,31,30,31,31,30,31,30,31]&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',&lt;/code&gt;&lt;br /&gt;
&lt;code&gt; 'Juillet','Août','Septembre','Octobre','Novembre','Décembre']&lt;/code&gt;

Écrivez un petit programme qui insère dans la seconde liste tous les éléments de la première, de telle sorte que chaque nom de mois soit suivi du nombre de jours correspondant : &lt;code&gt;['Janvier',31,'Février',28,'Mars',31, etc.]&lt;/code&gt;.&lt;/li&gt;

&lt;li&gt;Créez une liste &lt;code&gt;A&lt;/code&gt; contenant quelques éléments. Effectuez une vraie copie de cette liste dans une nouvelle variable &lt;code&gt;B&lt;/code&gt;. Suggestion : créez d'abord une liste &lt;code&gt;B&lt;/code&gt; de même taille que &lt;code&gt;A&lt;/code&gt; mais ne contenant que des zéros. Remplacez ensuite tous ces zéros par les éléments tirés de &lt;code&gt;A&lt;/code&gt;.&lt;/li&gt;

&lt;li&gt;Même question, mais autre suggestion : créez d'abord une liste &lt;code&gt;B&lt;/code&gt; vide. Remplissez-la ensuite à l'aide des éléments de &lt;code&gt;A&lt;/code&gt; ajoutés l'un après l'autre.&lt;/li&gt;

&lt;li&gt;Même question, autre suggestion encore : pour créer la liste B, découpez dans la liste A une tranche incluant tous les éléments (à l'aide de l'opérateur [:]).&lt;/li&gt;

&lt;li&gt;Un ''nombre premier'' est un nombre qui n'est divisible que par un et par lui-même. Écrivez un programme qui établisse la liste de tous les nombres premiers compris entre 1 et 1000, en utilisant la méthode du ''{{w|crible d'Ératosthène}}'' :

* Créez une liste de 1000 éléments, chacun initialisé à la valeur 1.
* Parcourez cette liste à partir de l'élément d'indice 2 : si l'élément analysé possède la valeur 1, mettez à zéro tous les autres éléments de la liste, dont les indices sont des multiples entiers de l'indice auquel vous êtes arrivé.

Lorsque vous aurez parcouru ainsi toute la liste, les indices des éléments qui seront restés à 1 seront les nombres premiers recherchés.

En effet, à partir de l'indice 2, vous annulez tous les éléments d'indices pairs : 4, 6, 8, 10, etc. Avec l'indice 3, vous annulez les éléments d'indices 6, 9, 12, 15, etc., et ainsi de suite.

Seuls resteront à 1 les éléments dont les indices sont effectivement des nombres premiers.&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Insertion de nouveaux éléments dans une liste existante

t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',
      'Juillet','Août','Septembre','Octobre','Novembre','Décembre']

c, d = 1, 0
while d &lt; 12 :
     t2[c:c] = [t1[d]]       # ! l'élément inséré doit être une liste
     c, d = c+2, d+1
&lt;/pre&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Crible d’Ératosthène pour rechercher les nombres premiers de 1 à 999

# Créer une liste de 1000 éléments 1 (leurs indices vont de 0 à 999) :
lst = [1]*1000           
# Parcourir la liste à partir de l'élément d'indice 2:
for i in range(2,1000):
    # Mettre à zéro les éléments suivants dans la liste,
    # dont les indices sont des multiples de i :
    for j in range(i*2, 1000, i):
        lst[j] = 0

# Afficher les indices des éléments restés à 1 (on ignore l'élément 0) :
for i in range(1,1000):
    if lst[i]:
        print i,
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Déterminez vous-même ce qui se passe lorsque l'un ou l'autre des indices de découpage est erroné, et décrivez cela le mieux possible (si le second indice est plus petit que le premier, par exemple, ou bien si le second indice est plus grand que la taille de la chaîne).&lt;/li&gt;

&lt;li&gt;Découpez une grande chaîne en fragments de cinq caractères chacun. Rassemblez ces morceaux dans l'ordre inverse.&lt;/li&gt;

&lt;li&gt;Tâchez d'écrire un script qui fera exactement le contraire de ce que fait l'opérateur d'indexage ([]) : au lieu de partir d'un index donné pour retrouver le caractère correspondant, il devra retrouver l'index correspondant à un caractère donné, à partir du nom de la chaîne à traiter et du caractère à trouver. Exemple : pour &lt;code&gt;&quot;Juliette &amp; Roméo&quot;, &quot;&amp;&quot;&lt;/code&gt; il devra afficher : 9, ou -1 si le caractère est introuvable.

&lt;li&gt;Améliorez le script en lui ajoutant une troisième variable : l'index à partir duquel la recherche doit s'effectuer dans la chaîne. Ainsi par exemple, pour : &lt;code&gt;&quot;César &amp; Cléopâtre&quot;, &quot;r&quot;, 5&lt;/code&gt;, il devra afficher : 15 (et non 4 !)&lt;/li&gt;

&lt;li&gt;Écrivez un script qui compte le nombre d'occurrences d'un caractère donné dans une chaîne. Ainsi, pour &lt;code&gt;&quot;ananas au jus&quot;, &quot;a&quot;&lt;/code&gt; il devra afficher : 4.
&lt;/li&gt;
&lt;/ol&gt;

{{solution}}
&lt;ol&gt;
&lt;li&gt;''IndexError: list index out of range''&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Découpage d'une chaîne en fragments :
chain =&quot;abcdefghijklmnopqrstuvwxyz123456789&quot;
n = 5

# Découpage de &quot;chain&quot; en une liste de fragments de n caractères&quot;
d, f = 0, n             # indices de début et de fin de fragment
tt = []                 # liste à construire
while d &lt; len(chain):
	if f &gt; len(chain):  # on ne peut pas découper au-delà de la fin
		f = len(chain)
	fr = chain[d:f]     # découpage d'un fragment
	tt.append(fr)       # ajout du fragment à la liste
	d, f = f, f + n      # indices suivants 
print(tt)

# Rassemble les éléments de la liste tt dans l'ordre inverse&quot;
chain = &quot;&quot;              # chaîne à construire
i = len(tt)             # on commence par la fin de la liste
while i &gt; 0 :
	i = i - 1           # le dernier élément possède l'indice n - 1
	chain = chain + tt[i]
print(chain)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Rechercher l'indice d'un caractère dans une chaîne
chain, car = &quot;Coucou c'est moi&quot;, &quot;z&quot;
start = 0

# Trouve l'indice du caractère car dans &quot;chain&quot;
i = start
while i &lt; len(chain):
	if chain[i] == car:
		print(i)	# le caractère est trouvé -&gt; on termine
	i = i + 1
print(-1)       		# toute la chaîne a été scannée sans succès 

# Autres tests :
chain, car = &quot;Juliette &amp; Roméo&quot;, &quot;&amp;&quot;
chain, car, start = &quot;César &amp; Cléopâtre&quot;, &quot;r&quot;, 5
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{exercices}}
&lt;ol&gt;
&lt;li&gt;Soient les listes suivantes :
&lt;syntaxhighlight lang=python&gt;
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin',
      'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']
&lt;/syntaxhighlight&gt;
Écrivez un petit programme qui crée une nouvelle liste t3. Celle-ci devra contenir tous les éléments des deux listes en les alternant, de telle manière que chaque nom de mois soit suivi du nombre de jours correspondant : &lt;code&gt;['Janvier',31,'Février',28,'Mars',31, etc...]&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui affiche « proprement » tous les éléments d'une liste. Si on l'appliquait par exemple à la liste t2 de l'exercice ci-dessus, on devrait obtenir :
&lt;pre&gt;
Janvier Février Mars Avril Mai Juin Juillet Août Septembre Octobre Novembre Décembre
&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui recherche le plus grand élément présent dans une liste donnée. Par exemple, si on l'appliquait à la liste &lt;code&gt;[32, 5, 12, 8, 3, 75, 2, 15]&lt;/code&gt;, ce programme devrait afficher :
&lt;pre&gt;
le plus grand élément de cette liste a la valeur 75.
&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui analyse un par un tous les éléments d'une liste de nombres (par exemple celle de l'exercice précédent) pour générer deux nouvelles listes. L'une contiendra seulement les nombres pairs de la liste initiale, et l'autre les nombres impairs. Par exemple, si la liste initiale est celle de l'exercice précédent, le programme devra construire une liste pairs qui contiendra &lt;code&gt;[32, 12, 8, 2]&lt;/code&gt;, et une liste impairs qui contiendra &lt;code&gt;[5, 3, 75, 15]&lt;/code&gt;. Astuce : pensez à utiliser l'opérateur modulo (%) déjà cité précédemment.&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui analyse un par un tous les éléments d'une liste de mots (par exemple : &lt;code&gt;['Jean', 'Maximilien', 'Brigitte', 'Sonia', 'Jean-Pierre', 'Sandra']&lt;/code&gt; pour générer deux nouvelles listes. L'une contiendra les mots comportant moins de 6 caractères, l'autre les mots comportant 6 caractères ou davantage.&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Combinaison de deux listes en une seule

# Listes fournies au départ :
t1 = [31,28,31,30,31,30,31,31,30,31,30,31]
t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',
      'Juillet','Août','Septembre','Octobre','Novembre','Décembre']
# Nouvelle liste à construire (vide au départ) :
t3 = []
# Boucle de traitement :
i = 0
while i &lt; len(t1):
    t3.append(t2[i])
    t3.append(t1[i])
    i = i + 1

# Affichage :
print t3 
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Affichage des éléments d'une liste

# Liste fournie au départ :
t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',
      'Juillet','Août','Septembre','Octobre','Novembre','Décembre']
# Affichage :
i = 0
while i &lt; len(t2):
    print t2[i],
    i = i + 1
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Recherche du plus grand élément d'une liste

# Liste fournie au départ :
tt = [32, 5, 12, 8, 3, 75, 2, 15]
# Au fur et à mesure du traitement de la liste, on mémorisera dans
# la variable ci-dessous la valeur du plus grand élément déjà trouvé :
max = 0
# Examen de tous les éléments :
i = 0
while i &lt; len(tt):
    if tt[i] &gt; max:
        max = tt[i]         # mémorisation d'un nouveau maximum
    i = i + 1
# Affichage :
print &quot;Le plus grand élément de cette liste a la valeur&quot;, max
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Séparation des nombres pairs et impairs

# Liste fournie au départ :
tt = [32, 5, 12, 8, 3, 75, 2, 15]
pairs = []
impairs = []
# Examen de tous les éléments :
i = 0
while i &lt; len(tt):
    if tt[i] % 2 == 0:
        pairs.append(tt[i])
    else:
        impairs.append(tt[i])
    i = i + 1
# Affichage :
print &quot;Nombres pairs :&quot;, pairs
print &quot;Nombres impairs :&quot;, impairs
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{Exercices}}
# Écrivez un script qui génère la liste des carrés et des cubes des nombres de 20 à 40.
# Écrivez un script qui crée automatiquement la liste des sinus des angles de 0° à 90° , par pas de 5°. Attention : la fonction sin() du module math considère que les angles sont fournis en radians (360° = 2 p radians)
# Écrivez un script qui permette d'obtenir à l'écran les 15 premiers termes des tables de multiplication par 2, 3, 5, 7, 11, 13, 17, 19  (ces nombres seront placés au départ dans une liste) sous la forme d'une table semblable à la suivante :&lt;br /&gt;&lt;code&gt;2   4   6   8  10  12  14  16  18  20  22  24  26  28  30&lt;/code&gt;&lt;br /&gt;&lt;code&gt;3   6   9  12  15  18  21  24  27  30  33  36  39  42  45&lt;/code&gt;&lt;br /&gt;&lt;code&gt;5  10  15  20  25  30  35  40  45  50  55  60  65  70  75&lt;/code&gt;&lt;br /&gt;etc.
# Soit la liste suivante :&lt;br /&gt;&lt;code&gt;['Jean-Michel', 'Marc', 'Vanessa', 'Anne', 'Maximilien', 'Alexandre-Benoît', 'Louise']&lt;/code&gt;&lt;br /&gt;Écrivez un script qui affiche chacun de ces noms avec le nombre de caractères correspondant.
# Vous disposez d'une liste de nombres entiers quelconques, certains d'entre eux étant présents en plusieurs exemplaires. Écrivez un script qui recopie cette liste dans une autre, en omettant les doublons. La liste finale devra être triée. 
# Écrivez un script qui recherche le mot le plus long dans une phrase donnée (l'utilisateur du programme doit pouvoir entrer une phrase de son choix). 
# Écrivez un script capable d'afficher la liste de tous les jours d'une année imaginaire, laquelle commencerait un Jeudi. Votre script utilisera lui-même trois listes : une liste des noms de jours de la semaine, une liste des noms des mois, et une liste des nombres de jours que comportent chacun des mois (ne pas tenir compte des années bissextiles).&lt;br /&gt;Exemple de sortie :&lt;br /&gt;&lt;code&gt;Jeudi 1 Janvier   Vendredi 2 Janvier   Samedi 3 Janvier   Dimanche 4 Janvier&lt;/code&gt;&lt;br /&gt;... et ainsi de suite jusqu'au &lt;code&gt;Jeudi 31 Décembre&lt;/code&gt;.
# Vous avez à votre disposition un fichier texte qui contient un certain nombre de noms d'élèves. Écrivez un script qui effectue une copie triée de ce fichier.
# Écrivez un script permettant de trier une liste. Il ne pourra pas utiliser la méthode intégrée &quot;sort()&quot; de Python : vous devez donc définir vous-même l'algorithme de tri.

{{solution}}
&lt;ol&gt;
&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Affichage de tables de multiplication
m, n = 3, 15
chain =&quot;&quot;
for i in range(n):
    v = m * (i+1)               # calcul d'un des termes
    chain = chain + &quot;%4d&quot; % (v) # formatage à 4 caractères
print(chain)
&lt;/syntaxhighlight&gt;
 3   6   9  12  15  18  21  24  27  30  33  36  39  42  45
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Simple parcours d'une liste :
lst = ['Jean-Michel', 'Marc', 'Vanessa', 'Anne',
       'Maximilien', 'Alexandre-Benoît', 'Louise']

for e in lst:
    print(&quot;%s : %s caractères&quot; % (e, len(e)))
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Élimination de doublons

lst = [9, 12, 40, 5, 12, 3, 27, 5, 9, 3, 8, 22, 40, 3, 2, 4, 6, 25]
lst2 = []

for el in lst:
    if el not in lst2:
        lst2.append(el)

lst2.sort()
print(lst2)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Afficher tous les jours d'une année :
## Cette variante utilise une liste de listes ##
## (que l'on pourrait aisément remplacer par deux listes distinctes)

# La liste ci-dessous contient deux éléments qui sont eux-mêmes des listes.
# l'élément 0 contient les nombres de jours de chaque mois, tandis que
# l'élément 1 contient les noms des douze mois :
mois = [[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
        ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet',
         'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']]

jour = ['Dimanche','Lundi','Mardi','Mercredi','Jeudi','Vendredi','Samedi']

ja, jm, js, m = 0, 0, 0, 0

while ja &lt;365:
    ja, jm = ja +1, jm +1    # ja = jour dans l'année, jm = jour dans le mois
    js = (ja +3) % 7         # js = jour de la semaine. Le décalage ajouté 
                             #      permet de choisir le jour de départ
  
    if jm &gt; mois[0][m]:               # élément m de l'élément 0 de la liste
        jm, m = 1, m+1

    print jour[js], jm, mois[1][m]    # élément m de l'élément 1 de la liste
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}</text>
      <sha1>t32e8kdng52pxzc7l9yd11wtwilvq46</sha1>
    </revision>
    <revision>
      <id>684294</id>
      <parentid>684289</parentid>
      <timestamp>2022-08-27T18:29:54Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44285" xml:space="preserve">&lt;noinclude&gt;{{Python}}&lt;/noinclude&gt;

== Déclaration ==
Les listes sont des séquences, des collections ordonnées d'objets séparés par des virgules. On les déclare avec l'opérateur d'indiçage ([]) :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt; maListe = ['a','b','c']
&gt;&gt; maListe
['a','b','c']
&lt;/syntaxhighlight&gt;

== Lecture ==
Comme les caractères dans une chaîne, les objets placés dans une liste sont rendus accessibles par l'intermédiaire d'un ''index'' (un nombre qui indique l'emplacement de l'objet dans la séquence, à partir de zéro). De plus, le ''slicing'' (« découpage en tranches ») permet aussi de dégager une sous-liste en précisant deux index correspondant aux bornes de la plage.

Une sortie indicée donne :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt; maListe[0]
'a'

&gt;&gt; maListe[-1]
'c'
&lt;/syntaxhighlight&gt;

Une séquence donne par slicing :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt; maListe[0:2]
['a','b']

&gt;&gt; maListe[1:]
['b','c']
&lt;/syntaxhighlight&gt;

=== Types ===
Les éléments qui constituent une liste peuvent être de types variés :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
&gt;&gt;&gt; print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
&lt;/syntaxhighlight&gt;

Dans cet exemple, en effet, les premiers éléments sont des chaînes de caractères, puis il y a un entier et un réel. À cet égard, le concept de liste est donc différent des tableaux (''array'') que l'on rencontre les langages de programmation de {{wt|bas niveau}}, où tous les éléments doivent être du même type.

=== Recherche ===
Vous pouvez aisément déterminer si un élément fait partie d'une liste à l'aide de l'instruction &lt;code&gt;in&lt;/code&gt; :
&lt;syntaxhighlight lang=python&gt;
 print(&quot;a&quot; in [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])      # True
 print(not &quot;a&quot; in [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;])  # False
&lt;/syntaxhighlight&gt;

Si l'emplacement de l'élément importe dans la liste :
&lt;syntaxhighlight lang=python&gt;
 print [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;].index(&quot;a&quot;) == 0 # True
 print [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;].index(&quot;z&quot;)      # ValueError
&lt;/syntaxhighlight&gt;

== Modification ==
=== Affectation ===
À la différence de ce qui se passe pour les chaînes, qui constituent un type de données non-modifiables, il est possible de changer les éléments individuels d'une liste :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]
&gt;&gt;&gt; jour[5] = jour[5] + 1016
&gt;&gt;&gt; print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 1492, 3.142]
&lt;/syntaxhighlight&gt;

Les exemples ci-dessus devraient attirer votre attention sur le fait qu'une ''tranche'' découpée dans une liste est toujours elle-même une liste (même s'il s'agit d'une tranche qui ne contient qu'un seul élément), alors qu'un élément isolé peut contenir n'importe quel type de donnée.

Exemple en deux dimensions :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', ['samedi matin', 'samedi après-midi', 'samedi soir'], 'dimanche']
&gt;&gt;&gt; jour[5][0] = &quot;samedi midi&quot;
&gt;&gt;&gt; jour
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', ['samedi midi', 'samedi après-midi', 'samedi soir'], 'dimanche']
&lt;/syntaxhighlight&gt;
Ainsi, dans l'exemple ci-dessus on remplace le premier élément d'une liste (n° 0), qui est elle-même l'élément n° 5 d'une autre liste.

=== Opérations ===
On peut appliquer aux listes les opérateurs + (concaténation) et * (multiplication) :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; fruits = ['orange','citron']
&gt;&gt;&gt; legumes = ['poireau','oignon','tomate']
&gt;&gt;&gt; fruits + legumes
['orange', 'citron', 'poireau', 'oignon', 'tomate']
&gt;&gt;&gt; fruits * 3
['orange', 'citron', 'orange', 'citron', 'orange', 'citron']
&lt;/syntaxhighlight&gt;

L'opérateur * est particulièrement utile pour créer une liste de &quot;n&quot; éléments identiques :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; sept_zeros = [0]*7
&gt;&gt;&gt; sept_zeros
[0, 0, 0, 0, 0, 0, 0]
&lt;/syntaxhighlight&gt;

=== Techniques de slicing avancées pour modifier une liste ===
==== Insertion ====
Insertion d'un ou plusieurs éléments n'importe où dans une liste :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; mots = ['jambon', 'fromage', 'confiture', 'chocolat']
&gt;&gt;&gt; mots[2:2] = [&quot;miel&quot;]
&gt;&gt;&gt; mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat']
&gt;&gt;&gt; mots[5:5] = ['saucisson', 'ketchup']
&gt;&gt;&gt; mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat', 'saucisson', 'ketchup']
&lt;/syntaxhighlight&gt;

Pour utiliser cette technique, vous devez prendre en compte les particularités suivantes :

* Si vous utilisez l'opérateur &lt;code&gt;[ ]&lt;/code&gt; à la gauche du signe égale pour effectuer une insertion ou une suppression d'élément(s) dans une liste, vous devez obligatoirement y indiquer une « tranche » dans la liste cible (c'est-à-dire deux index réunis par le symbole &quot;:&quot;), et non un élément isolé dans cette liste.

* L'élément que vous fournissez à la droite du signe égale doit lui-même être une liste. Si vous n'insérez qu'un seul élément, il vous faut donc le présenter entre crochets pour le transformer d'abord en une liste d'un seul élément. Notez bien que l'élément &lt;code&gt;mots[1]&lt;/code&gt; n'est pas une liste (c'est la chaîne &lt;code&gt;fromage&lt;/code&gt;), alors que l'élément &lt;code&gt;mots[1:3]&lt;/code&gt; en est une.

==== Suppression ====
Suppression / remplacement d'éléments :
&lt;syntaxhighlight lang=python line&gt;
&gt;&gt;&gt; mots[2:5] = []                       # [] désigne une liste vide
&gt;&gt;&gt; mots
['jambon','fromage','saucisson', 'ketchup']
&gt;&gt;&gt; mots[1:3] = ['salade']
&gt;&gt;&gt; mots
['jambon', 'salade', 'ketchup']
&gt;&gt;&gt; mots[1:] = ['mayonnaise', 'poulet', 'tomate']
&gt;&gt;&gt; mots
['jambon', 'mayonnaise', 'poulet', 'tomate']
&lt;/syntaxhighlight&gt;
 
* À la première ligne de cet exemple, nous remplaçons la tranche [2:5] par une liste vide, ce qui correspond à un effacement.

* À la quatrième ligne, nous remplaçons une tranche par un seul élément. (Notez encore une fois que cet élément doit lui-même être « présenté » comme une liste).

* À la 7e ligne, nous remplaçons une tranche de deux éléments par une autre qui en comporte 3.

==== Différence ====
Pour obtenir la différence entre deux listes :
&lt;syntaxhighlight lang=python&gt;
a = ['jambon','fromage','saucisson', 'ketchup']
b = ['jambon', 'mayonnaise', 'poulet', 'tomate']
print([item for item in a if item not in b])
# ['fromage', 'saucisson', 'ketchup']
&lt;/syntaxhighlight&gt;

==== Intersection ====
Pour l'intersection entre deux listes (en préservant l'ordre des éléments y compris leurs doublons), on applique la différence de la différence :
&lt;syntaxhighlight lang=python&gt;
a = ['jambon','fromage','saucisson', 'ketchup']
b = ['jambon', 'mayonnaise', 'poulet', 'tomate']
dif = [item for item in a if item not in b]
print [item for item in a if item not in dif]
# ['jambon']
&lt;/syntaxhighlight&gt;

=== Copie ===

Considérons que vous disposez d'une liste fable que vous souhaitez recopier dans une nouvelle variable que vous appellerez phrase. La première idée qui vous viendra à l'esprit sera certainement d'écrire une simple affectation telle que :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; phrase = fable
&lt;/syntaxhighlight&gt;

En procédant ainsi, sachez que vous ne créez pas une véritable copie. À la suite de cette instruction, il n'existe toujours qu'une seule liste dans la mémoire de l'ordinateur. Ce que vous avez créé est seulement ''une nouvelle référence vers cette liste''. Essayez par exemple :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; fable = ['Je','plie','mais','ne','romps','point']
&gt;&gt;&gt; phrase = fable
&gt;&gt;&gt; fable[4] ='casse'
&gt;&gt;&gt; phrase
['Je', 'plie', 'mais', 'ne', 'casse', 'point']
&lt;/syntaxhighlight&gt;

Si la variable phrase contenait une véritable copie de la liste, cette copie serait indépendante de l'original et ne devrait donc pas pouvoir être modifiée par une instruction telle que celle de la troisième ligne, qui s'applique à la variable &lt;code&gt;fable&lt;/code&gt;. Vous pouvez encore expérimenter d'autres modifications, soit au contenu de &lt;code&gt;fable&lt;/code&gt;, soit au contenu de phrase. Dans tous les cas, vous constaterez que les modifications de l'une sont répercutées dans l'autre, et vice-versa.

En fait, les noms &lt;code&gt;fable&lt;/code&gt; et &lt;code&gt;phrase&lt;/code&gt; désignent tous deux un seul et même objet en mémoire. Pour décrire cette situation, les informaticiens diront que le nom phrase est un ''alias'' du nom &lt;code&gt;fable&lt;/code&gt;.

[[Image:Apprendre à programmer avec Python 32.png|center|500px|Schéma de la copie d'une liste.]]

Nous verrons plus tard l'utilité des ''alias''. Pour l'instant, nous voudrions disposer d'une technique pour effectuer une véritable copie d'une liste. Avec les notions vues précédemment, vous devriez pouvoir en trouver une par vous-même.  

{{remarque|Python vous autorise à « étendre » une longue instruction sur plusieurs lignes, si vous continuez à encoder quelque chose qui est délimité par une paire de parenthèses, de crochets ou d'accolades. Vous pouvez traiter ainsi des expressions parenthésées, ou encore la définition de longues listes, de grands tuples ou de grands dictionnaires. Le niveau d'indentation n'a pas d'importance : l'interpréteur détecte la fin de l'instruction, là où la paire syntaxique est refermée.}}

Cette fonctionnalité vous permet d'améliorer la lisibilité de vos programmes. Exemple :

&lt;syntaxhighlight lang=python&gt;
couleurs = ['noir', 'brun', 'rouge',
            'orange', 'jaune', 'vert',
            'bleu', 'violet', 'gris', 'blanc']
&lt;/syntaxhighlight&gt;


== Méthodes ==

Sous Python, les listes sont des objets à part entière, et vous pouvez donc leur appliquer un certain nombre de ''méthodes'' particulièrement efficaces, après l'opérateur &quot;.&quot; :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; nombres = [17, 38, 10, 25, 72]

&gt;&gt;&gt; nombres.sort()                 # trier la liste
&gt;&gt;&gt; nombres
[10, 17, 25, 38, 72]

&gt;&gt;&gt; nombres.append(12)             # ajouter un élément à la fin
&gt;&gt;&gt; nombres
[10, 17, 25, 38, 72, 12]

&gt;&gt;&gt; nombres.reverse()              # inverser l'ordre des éléments
&gt;&gt;&gt; nombres
[12, 72, 38, 25, 17, 10]

&gt;&gt;&gt; nombres.index(17)              # retrouver l'index d'un élément
4

&gt;&gt;&gt; nombres.remove(38)             # enlever (effacer) un élément
&gt;&gt;&gt; nombres
[12, 72, 25, 17, 10]
&lt;/syntaxhighlight&gt;

=== ''append'' ===
&lt;code&gt;append()&lt;/code&gt; (ajouter) : l'exemple suivant qui fait appel à la méthode &quot;append&quot; de l'objet &quot;liste&quot; (déclarée vide) illustre ce concept.

Il s'agit de remplir la hotte du Père Noël.
&lt;syntaxhighlight lang=python&gt;
 #!/usr/bin/python
 # -*- coding: iso8859-1 -*-
 
 # on prépare une liste encore vide
 cadeaux = []
 
 # on va ajouter des éléments à la liste
 unCadeau = &quot;&quot;
 
 # la suite des éléments à introduire dans la liste est définie par l'utilisateur
 # lorsqu'il a terminé, l'utilisateur indique le mot &quot;fin&quot; qui ne sera pas introduit dans la liste
 while unCadeau &lt;&gt; &quot;fin&quot;:
 	unCadeau = raw_input (&quot;Père Noël, je voudrais que tu m'apportes &quot;)
        # si l'utilisateur n'a pas frappé &quot;fin&quot;, le mot est ajouté à la liste
 	if unCadeau &lt;&gt; &quot;fin&quot;:
 		cadeaux.append(unCadeau)
 
 # finalement, on écrit la suite des éléments introduits dans la liste
 for chaqueCadeau in cadeaux:
 	print chaqueCadeau
&lt;/syntaxhighlight&gt;

=== ''split'' ===
&lt;code&gt;split()&lt;/code&gt; : convertit une chaîne en une liste de sous-chaînes. On peut choisir le caractère séparateur en le fournissant comme argument, sinon c'est un espace, par défaut.
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; chaine =&quot;Votez pour moi&quot;
&gt;&gt;&gt; tableau = chaine.split()
&gt;&gt;&gt; print tableau
['Votez', 'pour', 'moi']

&gt;&gt;&gt; chaine = &quot;Cet exemple, parmi d'autres, peut encore servir&quot;
&gt;&gt;&gt; chaine.split(&quot;,&quot;)
['Cet exemple', &quot; parmi d'autres&quot;, ' peut encore servir']
&lt;/syntaxhighlight&gt;

=== ''join'' ===
&lt;code&gt;join(liste)&lt;/code&gt; : rassemble une liste de chaînes en une seule (Cette méthode fait donc l'inverse de la précédente). Attention : la chaîne à laquelle on applique cette méthode est celle qui servira de séparateur (un ou plusieurs caractères) ; l'argument transmis est la liste des chaînes à rassembler.
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; tableau = [&quot;Salut&quot;, &quot;les&quot;, &quot;copains&quot;]
&gt;&gt;&gt; print  &quot; &quot;.join(tableau)
Salut les copains
&gt;&gt;&gt; print  &quot;___&quot;.join(tableau)
Salut___les___copains
&lt;/syntaxhighlight&gt;

=== ''pop'' ===
&lt;code&gt;pop(i)&lt;/code&gt; retire et renvoie l'élément de la liste d'index ''i''. Si ''i'' est vide, il traite le dernier élément.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; list = [1, 2, 3, 4]

&gt;&gt;&gt; print(list.pop(0))
1
&gt;&gt;&gt; list
[2, 3, 4]

&gt;&gt;&gt; print(list.pop())
4
&gt;&gt;&gt;list
[2, 3]
&lt;/syntaxhighlight&gt;


== Fonctions ==
=== ''len'' ===
La ''fonction intégrée'' &lt;code&gt;len()&lt;/code&gt;, que nous avons déjà rencontrée à propos des chaînes, s'applique aussi aux listes. Elle renvoie le nombre d'éléments présents dans la liste :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; len(jour)
7
&lt;/syntaxhighlight&gt;

Supposons par exemple que vous voulez créer une liste &lt;code&gt;B&lt;/code&gt; qui contienne le même nombre d'éléments qu'une autre liste &lt;code&gt;A&lt;/code&gt;. Vous pouvez obtenir ce résultat de différentes manières, mais l'une des plus simples consistera à effectuer : &lt;code&gt;B = [0]*len(A)&lt;/code&gt;.

=== ''del'' ===
Une autre ''fonction intégrée'' permet de supprimer d'une liste un élément ou plusieurs éléments quelconques à partir de leurs index. Il s'agit de la fonction &lt;code&gt;del()&lt;/code&gt; :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 476, 3.142]

&gt;&gt;&gt; del(jour[5:7])
&gt;&gt;&gt; print(jour)
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']

&gt;&gt;&gt; del(jour[0])
&gt;&gt;&gt; print(jour)
['mardi', 'mercredi', 'jeudi', 'vendredi']
&lt;/syntaxhighlight&gt;

{{remarque|notez bien la différence entre la méthode &lt;code&gt;remove()&lt;/code&gt; et la fonction &lt;code&gt;del()&lt;/code&gt; : &lt;code&gt;del&lt;/code&gt; travaille avec un indice ou une tranche d'indices, tandis que &lt;code&gt;remove()&lt;/code&gt; recherche ''une valeur'' (si plusieurs éléments de la liste possèdent la même valeur, seul le premier est effacé).}}

=== ''min'' et ''max'' ===
* &lt;code&gt;min(liste)&lt;/code&gt; : minimum d'une liste (élément ayant la plus petite valeur).
* &lt;code&gt;max(liste)&lt;/code&gt; : maximum d'une liste.

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; jour = ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi']

&gt;&gt;&gt; min(jour)
'jeudi'

&gt;&gt;&gt; max(jour)
'vendredi'
&lt;/syntaxhighlight&gt;

=== ''range'' ===
Si vous devez manipuler des séquences de nombres, vous pouvez les créer très aisément à l'aide de cette fonction :
&lt;pre&gt;
&gt;&gt;&gt; range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
&lt;/pre&gt;
Sous python 3.6:
print(list(range(10)))
La fonction &lt;code&gt;range()&lt;/code&gt; génère une liste de nombres entiers de valeurs croissantes. Si vous appelez &lt;code&gt;range()&lt;/code&gt; avec un seul argument, la liste contiendra un nombre de valeurs égal à l'argument fourni, mais en commençant à partir de zéro (''c'est-à-dire que &lt;code&gt;range(n)&lt;/code&gt; génère les nombres de 0 à n-1'').

Notez bien que l'argument fourni n'est jamais dans la liste générée.

On peut aussi utiliser &lt;code&gt;range()&lt;/code&gt; avec deux, ou même trois arguments séparés par des virgules, afin de générer des séquences de nombres plus spécifiques :

&lt;pre&gt;
&gt;&gt;&gt; range(5,13)
[5, 6, 7, 8, 9, 10, 11, 12]
&gt;&gt;&gt; range(3,16,3)
[3, 6, 9, 12, 15]
&lt;/pre&gt;

Si vous avez du mal à assimiler l'exemple ci-dessus, considérez que &lt;code&gt;range()&lt;/code&gt; attend toujours trois arguments, que l'on pourrait intituler &lt;code&gt;FROM&lt;/code&gt;, &lt;code&gt;TO&lt;/code&gt; et &lt;code&gt;STEP&lt;/code&gt;. &lt;code&gt;FROM&lt;/code&gt; est la première valeur à générer, &lt;code&gt;TO&lt;/code&gt; est la dernière (ou plutôt la dernière + un), et &lt;code&gt;STEP&lt;/code&gt; le « pas » à sauter pour passer d'une valeur à la suivante. S'ils ne sont pas fournis, les paramètres &lt;code&gt;FROM&lt;/code&gt; et &lt;code&gt;STEP&lt;/code&gt; prennent leurs valeurs par défaut, qui sont respectivement 0 et 1.

=== Parcours d'une liste à l'aide de for, range() et len() ===

L'instruction &lt;code&gt;for&lt;/code&gt; est l'instruction idéale pour parcourir une liste :

&lt;pre&gt;
&gt;&gt;&gt; prov = ['La','raison','du','plus','fort','est','toujours','la','meilleure']
&gt;&gt;&gt; for mot in prov:
       print mot,
La raison du plus fort est toujours la meilleure
&lt;/pre&gt;

Il est très pratique de combiner les fonctions &lt;code&gt;range()&lt;/code&gt; et &lt;code&gt;len()&lt;/code&gt; pour obtenir automatiquement tous les indices d'une séquence (liste ou chaîne). Exemple :

&lt;syntaxhighlight lang=python&gt;
fable = ['Maître','Corbeau','sur','un','arbre','perché']
for index in range(len(fable)):
    print index, fable[index]
&lt;/syntaxhighlight&gt;

Mais il existe également une syntaxe adaptée à cela :

&lt;syntaxhighlight lang=python&gt;
for (cle, valeur) in enumerate(fable):
    print(cle, valeur)
&lt;/syntaxhighlight&gt;

L'exécution de ce script donne le résultat :
&lt;pre&gt;
0 Maître
1 Corbeau
2 sur
3 un
4 arbre
5 perché
&lt;/pre&gt;

Tableau à trois lignes :
&lt;syntaxhighlight lang=python&gt;
monTableau = range(1, 5)
monTableau[1] = u'ligne 1'
monTableau[2] = u'ligne 2'
monTableau[3] = u'ligne 3'

for ligne in range(1, 4):
    print(monTableau[ligne])
&lt;/syntaxhighlight&gt;

Tableau à deux dimensions :
&lt;syntaxhighlight lang=python&gt;
ligne = 3
colonne = 2
monTableau = [[0] * (colonne+1) for _ in range(ligne+1)]
monTableau[1][1] = u'1.1'
monTableau[1][2] = u'1.2'
monTableau[2][1] = u'2.1'
monTableau[2][2] = u'2.2'
monTableau[3][1] = u'3.1'
monTableau[3][2] = u'3.2'

for l in range(1, ligne + 1):
    for c in range(1, colonne + 1):
        print(monTableau[l][c])
&lt;/syntaxhighlight&gt;

==== Une conséquence du typage dynamique ====

Le type de la variable utilisée avec l'instruction &quot;for&quot; est redéfini continuellement au fur et à mesure du parcours : même si les éléments d'une liste sont de types différents, on peut parcourir cette liste à l'aide de &quot;for&quot; sans qu'il ne s'ensuive une erreur, car le type de la variable de parcours s'adapte automatiquement à celui de l'élément en cours de lecture. Exemple :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; divers = [3, 17.25, [5, 'Jean'], 'Linux is not Windoze']
&gt;&gt;&gt; for item in divers:
        print item, type(item)
&lt;/syntaxhighlight&gt;
 3 &lt;type 'int'&gt;
 17.25 &lt;type 'float'&gt;
 [5, 'Jean'] &lt;type 'list'&gt;
 Linux is not Windoze &lt;type 'str'&gt;

=== ''random'' ===

La plupart des programmes d'ordinateur font exactement la même chose chaque fois qu'on les exécute. De tels programmes sont dits ''déterministes''. Le déterminisme est certainement une bonne chose : nous voulons évidemment qu'une même série de calculs appliquée aux mêmes données initiales aboutisse toujours au même résultat.  Pour certaines applications, cependant, nous pouvons souhaiter que l'ordinateur soit imprévisible. Le cas des jeux constitue un exemple évident, mais il en existe bien d'autres.

Contrairement aux apparences, il n'est pas facile du tout d'écrire un algorithme qui soit réellement non-déterministe (c'est-à-dire qui produise un résultat totalement imprévisible). Il existe cependant des techniques mathématiques permettant de ''simuler'' plus ou moins bien l'effet du hasard.  Des livres entiers ont été écrits sur les moyens de produire ainsi un hasard « de bonne qualité ». Nous n'allons évidemment pas développer ici une telle question, mais rien ne vous empêche de consulter à ce sujet votre professeur de mathématiques.

Dans son module ''random'', Python propose toute une série de fonctions permettant de générer des nombres aléatoires qui suivent différentes distributions mathématiques. Nous n'examinerons ici que quelques-unes d'entre elles. Veuillez consulter la documentation en ligne pour découvrir les autres. Vous pouvez importer toutes les fonctions du module par : 

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; from random import *
&lt;/syntaxhighlight&gt;

Pour créer une liste de nombres réels aléatoires, de valeur comprise entre zéro et un :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; s = [0]*tailleListe
    for i in range(tailleListe):
        s[i] = random()
    print(s)
&lt;/syntaxhighlight&gt;

Vous pouvez constater que nous avons pris le parti de construire d'abord une liste de zéros de taille n, et ensuite de remplacer les zéros par des nombres aléatoires.

{{Exercices}}
# Réécrivez la fonction &lt;code&gt;list_aleat()&lt;/code&gt; ci-dessus, en utilisant la méthode &lt;code&gt;append()&lt;/code&gt; pour construire la liste petit à petit à partir d'une liste vide (au lieu de remplacer les zéros d'une liste préexistante comme nous l'avons fait).
# Écrivez une fonction &lt;code&gt;imprime_liste()&lt;/code&gt; qui permette d'afficher ligne par ligne tous les éléments contenus dans une liste de taille quelconque. Le nom de la liste sera fourni en argument. Utilisez cette fonction pour imprimer la liste de nombres aléatoires générés par la fonction &lt;code&gt;list_aleat()&lt;/code&gt;. Ainsi par exemple, l'instruction &lt;code&gt;imprime_liste(liste_aleat(8))&lt;/code&gt; devra afficher une colonne de 8 nombres réels aléatoires.
{{solution}}
#Réfléchissez !
#Réfléchissez !
{{fin}}

Les nombres ainsi générés sont-ils vraiment aléatoires ? C'est difficile à dire. Si nous ne tirons qu'un petit nombre de valeurs, nous ne pouvons rien vérifier. Par contre, si nous utilisons un grand nombre de fois la fonction &lt;code&gt;random()&lt;/code&gt;, nous nous attendons à ce que la moitié des valeurs produites soient plus grandes que 0,5 (et l'autre moitié plus petites).

Affinons ce raisonnement.  Les valeurs tirées sont toujours dans l'intervalle 0-1. Partageons cet intervalle en 4 fractions égales : de 0 à 0,25 , de 0,25 à 0,5 , de 0,5 à 0,75 , et de 0,75 à 1. Si nous tirons un grand nombre de valeurs au hasard, nous nous attendons à ce qu'il y en ait autant qui se situent dans chacune de nos 4 fractions.  Et nous pouvons généraliser ce raisonnement à un nombre quelconque de fractions, du moment qu'elles soient égales.

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Vous allez écrire un programme destiné à vérifier le fonctionnement du générateur de nombres aléatoires de Python en appliquant la théorie exposée ci-dessus. Votre programme devra donc :

a) Demander à l'utilisateur le nombre de valeurs à tirer au hasard à l'aide de la fonction &lt;code&gt;random()&lt;/code&gt;. Il serait intéressant que le programme propose un nombre par défaut (1000 par exemple).

b) Demander à l'utilisateur en combien de fractions il souhaite partager l'intervalle des valeurs possibles (c'est-à-dire l'intervalle de 0 à 1). Ici aussi, il faudrait proposer un nombre de par défaut (5 fractions, par exemple). Vous pouvez également limiter le choix de l'utilisateur à un nombre compris entre 2 et le 1/10e du nombre de valeurs tirées au hasard.

c) Construire une liste de N compteurs (N étant le nombre de fractions souhaitées). Chacun d'eux  sera évidemment initialisé à zéro.

d) Tirer au hasard toutes les valeurs demandées, à l'aide de la fonction &lt;code&gt;random()&lt;/code&gt;, et mémoriser ces valeurs dans une liste.

e) Mettre en œuvre un parcours de la liste des valeurs tirées au hasard (boucle), et effectuer un test sur chacune d'elles pour déterminer dans quelle fraction de l'intervalle 0-1 elle se situe. Incrémenter de une unité le compteur correspondant.

f) Lorsque c'est terminé, afficher l'état de chacun des compteurs.
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Test du générateur de nombres aléatoires :
from random import random           # tire au hasard un réel entre 0 et 1

n = raw_input(&quot;Nombre de valeurs à tirer au hasard (défaut = 1000) : &quot;)
if n == &quot;&quot;:
    nVal =1000
else:
    nVal = int(n)

n = raw_input(&quot;Nombre de fractions dans l'intervalle 0-1 (entre 2 et &quot;
              + str(nVal/10) + &quot;, défaut =5) : &quot;)
if n == &quot;&quot;:
    nFra =5
else:
    nFra = int(n)

if nFra &lt; 2:
    nFra =2
elif nFra &gt; nVal/10:
    nFra = nVal/10

print &quot;Tirage au sort des&quot;, nVal, &quot;valeurs ...&quot;
listVal = [0]*nVal                      # créer une liste de zéros
for i in range(nVal):                   # puis modifier chaque élément
    listVal[i] = random()

print &quot;Comptage des valeurs dans chacune des&quot;, nFra, &quot;fractions ...&quot;
listCompt = [0]*nFra                    # créer une liste de compteurs

# parcourir la liste des valeurs :
for valeur in listVal:
    # trouver l'index de la fraction qui contient la valeur :    
    index = int(valeur*nFra)
    # incrémenter le compteur correspondant :
    listCompt[index] = listCompt[index] +1

# afficher l'état des compteurs :
for compt in listCompt:
    print compt,
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

==== Exemple de résultats affichés par un programme de ce type ====

&lt;pre&gt;
Nombre de valeurs à tirer au hasard (défaut = 1000) : 100
Nombre de fractions dans l'intervalle 0-1 (entre 2 et 10, défaut =5) : 5
Tirage au sort des 100 valeurs ...
Comptage des valeurs dans chacune des 5 fractions ...
11 30 25 14 20 
Nombre de valeurs à tirer au hasard (défaut = 1000) : 10000
Nombre de fractions dans l'intervalle 0-1 (entre 2 et 1000, défaut =5) : 5
Tirage au sort des 10000 valeurs ...
Comptage des valeurs dans chacune des 5 fractions ...
1970 1972 2061 1935 2062
&lt;/pre&gt;

Une bonne approche de ce genre de problème consiste à essayer d'imaginer quelles fonctions simples vous pourriez écrire pour résoudre l'une ou l'autre partie du problème, puis de les utiliser dans un ensemble plus vaste.

Par exemple, vous pourriez chercher à définir d'abord une fonction &lt;code&gt;numeroFraction()&lt;/code&gt; qui servirait à déterminer dans quelle fraction de l'intervalle 0-1 une valeur tirée se situe. Cette fonction attendrait deux arguments (la valeur tirée, le nombre de fractions choisi par l'utilisateur) et fournirait en retour l'index du compteur à incrémenter (c'est-à-dire le n° de la fraction correspondante). Il existe peut-être un raisonnement mathématique simple qui permette de déterminer l'index de la fraction à partir de ces deux arguments. Pensez notamment à la fonction intégrée &lt;code&gt;int()&lt;/code&gt;, qui permet de convertir un nombre réel en nombre entier en éliminant sa partie décimale.

Si vous ne trouvez pas, une autre réflexion intéressante serait peut-être de construire d'abord une liste contenant les valeurs « pivots » qui délimitent les fractions retenues (par exemple 0 – 0,25 – 0,5 – 0,75 - 1 dans le cas de 4 fractions). La connaissance de ces valeurs faciliterait peut-être l'écriture de la fonction &lt;code&gt;numeroFraction()&lt;/code&gt; que nous souhaitons mettre au point.

Si vous disposez d'un temps suffisant, vous pouvez aussi réaliser une version graphique de ce programme, qui présentera les résultats sous la forme d'un histogramme (diagramme « en bâtons »).

==== Tirage au hasard de nombres entiers ====

Lorsque vous développerez des projets personnels, il vous arrivera fréquemment de souhaiter pouvoir disposer d'une fonction qui permette de tirer au hasard un nombre entier entre certaines limites. Par exemple, si vous voulez écrire un programme de jeu dans lequel des cartes à jouer sont tirées au hasard (à partir d'un jeu ordinaire de 52 cartes), vous aurez certainement l'utilité d'une fonction capable de tirer au hasard un nombre entier compris entre 1 et 52.

Vous pouvez pour ce faire utiliser la fonction &lt;code&gt;randrange()&lt;/code&gt; du module &lt;code&gt;random&lt;/code&gt;.

Cette fonction peut être utilisée avec 1, 2 ou 3 arguments.

Avec un seul argument, elle renvoie un entier compris entre zéro et la valeur de l'argument diminué d'une unité. Par exemple, &lt;code&gt;randrange(6)&lt;/code&gt; renvoie un nombre compris entre 0 et 5.

Avec deux arguments, le nombre renvoyé est compris entre la valeur du premier argument et la valeur du second argument diminué d'une unité. Par exemple, &lt;code&gt;randrange(2, 8)&lt;/code&gt; renvoie un nombre compris entre 2 et 7.

Si l'on ajoute un troisième argument, celui-ci indique que le nombre tiré au hasard doit faire partie d'une série limitée d'entiers, séparés les uns des autres par un certain intervalle, défini lui-même par ce troisième argument. Par exemple, &lt;code&gt;randrange(3, 13, 3)&lt;/code&gt; renverra un des nombres de la série 3, 6, 9, 12 :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; for i in range(15):
        print random.randrange(3,13,3),

3 12 6 9 6 6 12 6 3 6 9 3 6 12 12
&lt;/syntaxhighlight&gt;

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Écrivez un script qui tire au hasard des cartes à jouer. Le nom de la carte tirée doit être correctement présenté, « en clair ». Le programme affichera par exemple :

&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;Dix de Trèfle&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;As de Carreau&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;Huit de Pique&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;Frappez &lt;Enter&gt; pour tirer une carte :&lt;/code&gt; &lt;br /&gt;
&lt;code&gt;etc ...&lt;/code&gt;&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Tirage de cartes
from random import randrange

couleurs = ['Pique', 'Trèfle', 'Carreau', 'Cœur']
valeurs = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'valet', 'dame', 'roi', 'as']

# Construction de la liste des 52 cartes :
carte =[]
for coul in couleurs:
     for val in valeurs:
          carte.append(&quot;%s de %s&quot; % (str(val), coul))

# Tirage au hasard :
while 1:
     k = raw_input(&quot;Frappez &lt;c&gt; pour tirer une carte, &lt;Enter&gt; pour terminer &quot;) 
     if k ==&quot;&quot;:
          break
     r = randrange(52)
     print carte[r]
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

=== map ===
Permet d'appliquer une fonction à toutes les entrées d'une liste. Par exemple pour les ''trimer'' :
&lt;syntaxhighlight lang=python&gt;
l = [' ma super ligne 1\n', ' ma super ligne 2\n']
l = map(str.strip, l)
print l
# ['ma super ligne 1', 'ma super ligne 2']
&lt;/syntaxhighlight&gt;

== Exercices ==
{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Soient les listes suivantes :

&lt;code&gt;t1 = [31,28,31,30,31,30,31,31,30,31,30,31]&lt;/code&gt;&lt;br /&gt;
&lt;code&gt;t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',&lt;/code&gt;&lt;br /&gt;
&lt;code&gt; 'Juillet','Août','Septembre','Octobre','Novembre','Décembre']&lt;/code&gt;

Écrivez un petit programme qui insère dans la seconde liste tous les éléments de la première, de telle sorte que chaque nom de mois soit suivi du nombre de jours correspondant : &lt;code&gt;['Janvier',31,'Février',28,'Mars',31, etc.]&lt;/code&gt;.&lt;/li&gt;

&lt;li&gt;Créez une liste &lt;code&gt;A&lt;/code&gt; contenant quelques éléments. Effectuez une vraie copie de cette liste dans une nouvelle variable &lt;code&gt;B&lt;/code&gt;. Suggestion : créez d'abord une liste &lt;code&gt;B&lt;/code&gt; de même taille que &lt;code&gt;A&lt;/code&gt; mais ne contenant que des zéros. Remplacez ensuite tous ces zéros par les éléments tirés de &lt;code&gt;A&lt;/code&gt;.&lt;/li&gt;

&lt;li&gt;Même question, mais autre suggestion : créez d'abord une liste &lt;code&gt;B&lt;/code&gt; vide. Remplissez-la ensuite à l'aide des éléments de &lt;code&gt;A&lt;/code&gt; ajoutés l'un après l'autre.&lt;/li&gt;

&lt;li&gt;Même question, autre suggestion encore : pour créer la liste B, découpez dans la liste A une tranche incluant tous les éléments (à l'aide de l'opérateur [:]).&lt;/li&gt;

&lt;li&gt;Un ''nombre premier'' est un nombre qui n'est divisible que par un et par lui-même. Écrivez un programme qui établisse la liste de tous les nombres premiers compris entre 1 et 1000, en utilisant la méthode du ''{{w|crible d'Ératosthène}}'' :

* Créez une liste de 1000 éléments, chacun initialisé à la valeur 1.
* Parcourez cette liste à partir de l'élément d'indice 2 : si l'élément analysé possède la valeur 1, mettez à zéro tous les autres éléments de la liste, dont les indices sont des multiples entiers de l'indice auquel vous êtes arrivé.

Lorsque vous aurez parcouru ainsi toute la liste, les indices des éléments qui seront restés à 1 seront les nombres premiers recherchés.

En effet, à partir de l'indice 2, vous annulez tous les éléments d'indices pairs : 4, 6, 8, 10, etc. Avec l'indice 3, vous annulez les éléments d'indices 6, 9, 12, 15, etc., et ainsi de suite.

Seuls resteront à 1 les éléments dont les indices sont effectivement des nombres premiers.&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Insertion de nouveaux éléments dans une liste existante

t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',
      'Juillet','Août','Septembre','Octobre','Novembre','Décembre']

c, d = 1, 0
while d &lt; 12 :
     t2[c:c] = [t1[d]]       # ! l'élément inséré doit être une liste
     c, d = c+2, d+1
&lt;/pre&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Crible d’Ératosthène pour rechercher les nombres premiers de 1 à 999

# Créer une liste de 1000 éléments 1 (leurs indices vont de 0 à 999) :
lst = [1]*1000           
# Parcourir la liste à partir de l'élément d'indice 2:
for i in range(2,1000):
    # Mettre à zéro les éléments suivants dans la liste,
    # dont les indices sont des multiples de i :
    for j in range(i*2, 1000, i):
        lst[j] = 0

# Afficher les indices des éléments restés à 1 (on ignore l'élément 0) :
for i in range(1,1000):
    if lst[i]:
        print i,
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Déterminez vous-même ce qui se passe lorsque l'un ou l'autre des indices de découpage est erroné, et décrivez cela le mieux possible (si le second indice est plus petit que le premier, par exemple, ou bien si le second indice est plus grand que la taille de la chaîne).&lt;/li&gt;

&lt;li&gt;Découpez une grande chaîne en fragments de cinq caractères chacun. Rassemblez ces morceaux dans l'ordre inverse.&lt;/li&gt;

&lt;li&gt;Tâchez d'écrire un script qui fera exactement le contraire de ce que fait l'opérateur d'indexage ([]) : au lieu de partir d'un index donné pour retrouver le caractère correspondant, il devra retrouver l'index correspondant à un caractère donné, à partir du nom de la chaîne à traiter et du caractère à trouver. Exemple : pour &lt;code&gt;&quot;Juliette &amp; Roméo&quot;, &quot;&amp;&quot;&lt;/code&gt; il devra afficher : 9, ou -1 si le caractère est introuvable.

&lt;li&gt;Améliorez le script en lui ajoutant une troisième variable : l'index à partir duquel la recherche doit s'effectuer dans la chaîne. Ainsi par exemple, pour : &lt;code&gt;&quot;César &amp; Cléopâtre&quot;, &quot;r&quot;, 5&lt;/code&gt;, il devra afficher : 15 (et non 4 !)&lt;/li&gt;

&lt;li&gt;Écrivez un script qui compte le nombre d'occurrences d'un caractère donné dans une chaîne. Ainsi, pour &lt;code&gt;&quot;ananas au jus&quot;, &quot;a&quot;&lt;/code&gt; il devra afficher : 4.
&lt;/li&gt;
&lt;/ol&gt;

{{solution}}
&lt;ol&gt;
&lt;li&gt;''IndexError: list index out of range''&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Découpage d'une chaîne en fragments :
chain =&quot;abcdefghijklmnopqrstuvwxyz123456789&quot;
n = 5

# Découpage de &quot;chain&quot; en une liste de fragments de n caractères&quot;
d, f = 0, n             # indices de début et de fin de fragment
tt = []                 # liste à construire
while d &lt; len(chain):
	if f &gt; len(chain):  # on ne peut pas découper au-delà de la fin
		f = len(chain)
	fr = chain[d:f]     # découpage d'un fragment
	tt.append(fr)       # ajout du fragment à la liste
	d, f = f, f + n      # indices suivants 
print(tt)

# Rassemble les éléments de la liste tt dans l'ordre inverse&quot;
chain = &quot;&quot;              # chaîne à construire
i = len(tt)             # on commence par la fin de la liste
while i &gt; 0 :
	i = i - 1           # le dernier élément possède l'indice n - 1
	chain = chain + tt[i]
print(chain)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Rechercher l'indice d'un caractère dans une chaîne
chain, car = &quot;Coucou c'est moi&quot;, &quot;z&quot;
start = 0

# Trouve l'indice du caractère car dans &quot;chain&quot;
i = start
while i &lt; len(chain):
	if chain[i] == car:
		print(i)	# le caractère est trouvé -&gt; on termine
	i = i + 1
print(-1)       		# toute la chaîne a été scannée sans succès 

# Autres tests :
chain, car = &quot;Juliette &amp; Roméo&quot;, &quot;&amp;&quot;
chain, car, start = &quot;César &amp; Cléopâtre&quot;, &quot;r&quot;, 5
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{exercices}}
&lt;ol&gt;
&lt;li&gt;Soient les listes suivantes :
&lt;syntaxhighlight lang=python&gt;
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin',
      'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']
&lt;/syntaxhighlight&gt;
Écrivez un petit programme qui crée une nouvelle liste t3. Celle-ci devra contenir tous les éléments des deux listes en les alternant, de telle manière que chaque nom de mois soit suivi du nombre de jours correspondant : &lt;code&gt;['Janvier',31,'Février',28,'Mars',31, etc.]&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui affiche « proprement » tous les éléments d'une liste. Si on l'appliquait par exemple à la liste t2 de l'exercice ci-dessus, on devrait obtenir :
&lt;pre&gt;
Janvier Février Mars Avril Mai Juin Juillet Août Septembre Octobre Novembre Décembre
&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui recherche le plus grand élément présent dans une liste donnée. Par exemple, si on l'appliquait à la liste &lt;code&gt;[32, 5, 12, 8, 3, 75, 2, 15]&lt;/code&gt;, ce programme devrait afficher :
&lt;pre&gt;
le plus grand élément de cette liste a la valeur 75.
&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui analyse un par un tous les éléments d'une liste de nombres (par exemple celle de l'exercice précédent) pour générer deux nouvelles listes. L'une contiendra seulement les nombres pairs de la liste initiale, et l'autre les nombres impairs. Par exemple, si la liste initiale est celle de l'exercice précédent, le programme devra construire une liste pairs qui contiendra &lt;code&gt;[32, 12, 8, 2]&lt;/code&gt;, et une liste impairs qui contiendra &lt;code&gt;[5, 3, 75, 15]&lt;/code&gt;. Astuce : pensez à utiliser l'opérateur modulo (%) déjà cité précédemment.&lt;/li&gt;
&lt;li&gt;Écrivez un programme qui analyse un par un tous les éléments d'une liste de mots (par exemple : &lt;code&gt;['Jean', 'Maximilien', 'Brigitte', 'Sonia', 'Jean-Pierre', 'Sandra']&lt;/code&gt; pour générer deux nouvelles listes. L'une contiendra les mots comportant moins de 6 caractères, l'autre les mots comportant 6 caractères ou davantage.&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Combinaison de deux listes en une seule

# Listes fournies au départ :
t1 = [31,28,31,30,31,30,31,31,30,31,30,31]
t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',
      'Juillet','Août','Septembre','Octobre','Novembre','Décembre']
# Nouvelle liste à construire (vide au départ) :
t3 = []
# Boucle de traitement :
i = 0
while i &lt; len(t1):
    t3.append(t2[i])
    t3.append(t1[i])
    i = i + 1

# Affichage :
print t3 
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Affichage des éléments d'une liste

# Liste fournie au départ :
t2 = ['Janvier','Février','Mars','Avril','Mai','Juin',
      'Juillet','Août','Septembre','Octobre','Novembre','Décembre']
# Affichage :
i = 0
while i &lt; len(t2):
    print t2[i],
    i = i + 1
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Recherche du plus grand élément d'une liste

# Liste fournie au départ :
tt = [32, 5, 12, 8, 3, 75, 2, 15]
# Au fur et à mesure du traitement de la liste, on mémorisera dans
# la variable ci-dessous la valeur du plus grand élément déjà trouvé :
max = 0
# Examen de tous les éléments :
i = 0
while i &lt; len(tt):
    if tt[i] &gt; max:
        max = tt[i]         # mémorisation d'un nouveau maximum
    i = i + 1
# Affichage :
print &quot;Le plus grand élément de cette liste a la valeur&quot;, max
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Séparation des nombres pairs et impairs

# Liste fournie au départ :
tt = [32, 5, 12, 8, 3, 75, 2, 15]
pairs = []
impairs = []
# Examen de tous les éléments :
i = 0
while i &lt; len(tt):
    if tt[i] % 2 == 0:
        pairs.append(tt[i])
    else:
        impairs.append(tt[i])
    i = i + 1
# Affichage :
print &quot;Nombres pairs :&quot;, pairs
print &quot;Nombres impairs :&quot;, impairs
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{Exercices}}
# Écrivez un script qui génère la liste des carrés et des cubes des nombres de 20 à 40.
# Écrivez un script qui crée automatiquement la liste des sinus des angles de 0° à 90° , par pas de 5°. Attention : la fonction sin() du module math considère que les angles sont fournis en radians (360° = 2 p radians)
# Écrivez un script qui permette d'obtenir à l'écran les 15 premiers termes des tables de multiplication par 2, 3, 5, 7, 11, 13, 17, 19  (ces nombres seront placés au départ dans une liste) sous la forme d'une table semblable à la suivante :&lt;br /&gt;&lt;code&gt;2   4   6   8  10  12  14  16  18  20  22  24  26  28  30&lt;/code&gt;&lt;br /&gt;&lt;code&gt;3   6   9  12  15  18  21  24  27  30  33  36  39  42  45&lt;/code&gt;&lt;br /&gt;&lt;code&gt;5  10  15  20  25  30  35  40  45  50  55  60  65  70  75&lt;/code&gt;&lt;br /&gt;etc.
# Soit la liste suivante :&lt;br /&gt;&lt;code&gt;['Jean-Michel', 'Marc', 'Vanessa', 'Anne', 'Maximilien', 'Alexandre-Benoît', 'Louise']&lt;/code&gt;&lt;br /&gt;Écrivez un script qui affiche chacun de ces noms avec le nombre de caractères correspondant.
# Vous disposez d'une liste de nombres entiers quelconques, certains d'entre eux étant présents en plusieurs exemplaires. Écrivez un script qui recopie cette liste dans une autre, en omettant les doublons. La liste finale devra être triée. 
# Écrivez un script qui recherche le mot le plus long dans une phrase donnée (l'utilisateur du programme doit pouvoir entrer une phrase de son choix). 
# Écrivez un script capable d'afficher la liste de tous les jours d'une année imaginaire, laquelle commencerait un Jeudi. Votre script utilisera lui-même trois listes : une liste des noms de jours de la semaine, une liste des noms des mois, et une liste des nombres de jours que comportent chacun des mois (ne pas tenir compte des années bissextiles).&lt;br /&gt;Exemple de sortie :&lt;br /&gt;&lt;code&gt;Jeudi 1 Janvier   Vendredi 2 Janvier   Samedi 3 Janvier   Dimanche 4 Janvier&lt;/code&gt;&lt;br /&gt;... et ainsi de suite jusqu'au &lt;code&gt;Jeudi 31 Décembre&lt;/code&gt;.
# Vous avez à votre disposition un fichier texte qui contient un certain nombre de noms d'élèves. Écrivez un script qui effectue une copie triée de ce fichier.
# Écrivez un script permettant de trier une liste. Il ne pourra pas utiliser la méthode intégrée &quot;sort()&quot; de Python : vous devez donc définir vous-même l'algorithme de tri.

{{solution}}
&lt;ol&gt;
&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Affichage de tables de multiplication
m, n = 3, 15
chain =&quot;&quot;
for i in range(n):
    v = m * (i+1)               # calcul d'un des termes
    chain = chain + &quot;%4d&quot; % (v) # formatage à 4 caractères
print(chain)
&lt;/syntaxhighlight&gt;
 3   6   9  12  15  18  21  24  27  30  33  36  39  42  45
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Simple parcours d'une liste :
lst = ['Jean-Michel', 'Marc', 'Vanessa', 'Anne',
       'Maximilien', 'Alexandre-Benoît', 'Louise']

for e in lst:
    print(&quot;%s : %s caractères&quot; % (e, len(e)))
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Élimination de doublons

lst = [9, 12, 40, 5, 12, 3, 27, 5, 9, 3, 8, 22, 40, 3, 2, 4, 6, 25]
lst2 = []

for el in lst:
    if el not in lst2:
        lst2.append(el)

lst2.sort()
print(lst2)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Afficher tous les jours d'une année :
## Cette variante utilise une liste de listes ##
## (que l'on pourrait aisément remplacer par deux listes distinctes)

# La liste ci-dessous contient deux éléments qui sont eux-mêmes des listes.
# l'élément 0 contient les nombres de jours de chaque mois, tandis que
# l'élément 1 contient les noms des douze mois :
mois = [[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
        ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet',
         'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']]

jour = ['Dimanche','Lundi','Mardi','Mercredi','Jeudi','Vendredi','Samedi']

ja, jm, js, m = 0, 0, 0, 0

while ja &lt;365:
    ja, jm = ja +1, jm +1    # ja = jour dans l'année, jm = jour dans le mois
    js = (ja +3) % 7         # js = jour de la semaine. Le décalage ajouté 
                             #      permet de choisir le jour de départ
  
    if jm &gt; mois[0][m]:               # élément m de l'élément 0 de la liste
        jm, m = 1, m+1

    print jour[js], jm, mois[1][m]    # élément m de l'élément 1 de la liste
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}</text>
      <sha1>50pj5ewm8htbqr115r6drb3swd44n1s</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Classes</title>
    <ns>0</ns>
    <id>16113</id>
    <revision>
      <id>684238</id>
      <parentid>676685</parentid>
      <timestamp>2022-08-27T12:52:40Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="65741" xml:space="preserve">&lt;noinclude&gt;{{Python}}&lt;/noinclude&gt;


== Définition d'une classe élémentaire ==

Pour créer une nouvelle classe d'objets Python, donc un nouveau type de donnée, on utilise l'instruction &quot;&lt;code&gt;class&lt;/code&gt;&quot;. Les définitions de classes peuvent être situées n'importe où dans un programme, mais on les placera en général au début (ou bien dans un module à importer). 

Par exemple, nous allons maintenant créer un nouveau type composite : le type &quot;&lt;code&gt;Point&lt;/code&gt;&quot;. Ce type correspondra au concept de point en mathématiques. Dans un espace à deux dimensions, un point est caractérisé par deux nombres (ses coordonnées suivant x et y). En notation mathématique, on représente donc un point par ses deux coordonnées x et y enfermées dans une paire de parenthèses. On parlera par exemple du point (25, 17). Une manière naturelle de représenter un point sous Python serait d'utiliser pour les coordonnées deux valeurs de type ''float''. Nous voudrions cependant combiner ces deux valeurs dans une seule entité, ou un seul objet. Pour y arriver, nous allons définir une classe &lt;code&gt;Point()&lt;/code&gt; :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; class Point:
        &quot;Définition d'un point mathématique&quot;
&lt;/syntaxhighlight&gt;

Remarquons d'emblée que :

* L'instruction &lt;code&gt;class&lt;/code&gt; est un nouvel exemple d’''instruction composée''. Ce bloc doit contenir au moins une ligne. Dans notre exemple, cette ligne n'est rien d'autre qu'un simple commentaire. Par convention, si la première ligne suivant l'instruction &lt;code&gt;class&lt;/code&gt; est une chaîne de caractères, celle-ci sera considérée comme un commentaire et incorporée automatiquement dans un dispositif de documentation des classes qui fait partie intégrante de Python. Prenez donc l'habitude de toujours placer une chaîne décrivant la classe à cet endroit.

* Rappelez-vous aussi la convention qui consiste à toujours donner aux classes des noms qui commencent par une majuscule. Dans la suite de ce texte, nous respecterons encore une autre convention qui consiste à associer à chaque nom de classe une paire de parenthèses, comme nous le faisons déjà pour les noms de fonctions.

Nous pouvons dès à présent nous servir de cette classe pour créer des objets de ce type, par ''instanciation''. Créons par exemple un nouvel objet &lt;code&gt;p9&lt;/code&gt;.

{{remarque|1=Sous Python, on peut donc instancier un objet à l'aide d'une simple instruction d'affectation. D'autres langages imposent l'emploi d'une instruction spéciale, souvent appelée &quot;new&quot; pour bien montrer que l'on crée un nouvel objet à partir d'un moule. Exemple : &lt;code&gt;p9 = new Point()&lt;/code&gt;.}}

&lt;pre&gt;
&gt;&gt;&gt; p9 = Point()
&lt;/pre&gt;

Après cette instruction, la variable &lt;code&gt;p9&lt;/code&gt; contient la référence d'un nouvel objet &lt;code&gt;Point()&lt;/code&gt;. Nous pouvons dire également que &lt;code&gt;p9&lt;/code&gt; est une ''nouvelle instance'' de la classe &lt;code&gt;Point()&lt;/code&gt;.

{{remarque|Comme les fonctions, les classes auxquelles on fait appel dans une instruction doivent toujours être accompagnées de parenthèses (même si aucun argument n'est transmis).

Remarquez bien cependant que la ''définition'' d'une classe ne nécessite pas de parenthèses (contrairement à ce qui est de règle lors de la définition des fonctions), sauf si nous souhaitons que la classe en cours de définition dérive d'une autre classe préexistante.
}}

== Attributs (ou variables) d'instance ==

L'objet que nous venons de créer est une coquille vide. Nous pouvons ajouter des composants à cet objet par simple assignation, en utilisant le système de  qualification des noms par points.

{{remarque|Ce système de notation est similaire à celui que nous utilisons pour désigner les variables d'un module, comme par exemple &quot;math.pi&quot; ou &quot;string.uppercase&quot;. Les modules peuvent en effet contenir des fonctions, mais aussi des classes et des variables. Essayez par exemple :
&lt;syntaxhighlight lang=python&gt;
import  string
print string.uppercase # ABCDEFGHIJKLMNOPQRSTUVWXYZ
print string.lowercase # abcdefghijklmnopqrstuvwxyz
print string.hexdigits # 0123456789abcdefABCDEF
&lt;/syntaxhighlight&gt;
}}


Complétons la classe précédente avec les coordonnées d'un point :
&lt;syntaxhighlight lang=python&gt;
class Point:
    x = 0
    y = 0

p9 = Point()
p9.x = 3.0
p9.y = 4.0
print (p9.x, p9.y)
&lt;/syntaxhighlight&gt;
 (3.0, 4.0)

[[Image:Apprendre à programmer avec Python 34.png|200px|right|Schéma de variables d'instance]]

Les variables ainsi définies sont des ''attributs'' de l'objet &lt;code&gt;p9&lt;/code&gt;, ou encore des ''variables d'instance''. Elles sont incorporées, ou plutôt ''encapsulées'' dans l'objet. Le diagramme d'état ci-contre montre le résultat de ces affectations : la variable &lt;code&gt;p9&lt;/code&gt; contient la référence indiquant l'emplacement mémoire du nouvel objet, qui contient lui-même les deux attributs &lt;code&gt;x&lt;/code&gt; et &lt;code&gt;y&lt;/code&gt;.
 
On peut utiliser les attributs d'un objet dans n'importe quelle expression, comme toutes les variables ordinaires :

&lt;pre&gt;
&gt;&gt;&gt; print p9.x
3.0
&gt;&gt;&gt; print p9.x**2 + p9.y**2	
25.0
&lt;/pre&gt;

Du fait de leur encapsulation dans l'objet, les attributs sont des variables distinctes d'autres variables qui pourraient porter le même nom. Par exemple, l'instruction  &lt;code&gt;x = p9.x&lt;/code&gt;  signifie : « extraire de l'objet référencé par &lt;code&gt;p9&lt;/code&gt; la valeur de son attribut &lt;code&gt;x&lt;/code&gt;, et assigner cette valeur à la variable &lt;code&gt;x&lt;/code&gt; ».

Il n'y a pas de conflit entre la variable &lt;code&gt;x&lt;/code&gt; et l'attribut &lt;code&gt;x&lt;/code&gt; de l'objet &lt;code&gt;p9&lt;/code&gt;.  L'objet &lt;code&gt;p9&lt;/code&gt; contient en effet son propre espace de noms, indépendant de l'espace de nom principal où se trouve la variable &lt;code&gt;x&lt;/code&gt;.

{{remarque|1=Nous venons de voir qu'il est très aisé d'ajouter un attribut à un objet en utilisant une simple instruction d'assignation telle que &lt;code&gt;p9.x = 3.0&lt;/code&gt;. On peut se permettre cela sous Python (c'est une conséquence de l'assignation dynamique des variables), mais ''cela n'est pas vraiment recommandable''. En effet, nous n'utiliserons cette façon de faire uniquement dans le but de simplifier nos explications concernant les attributs d'instances.}}

== Passage d'objets comme arguments lors de l'appel d'une fonction ==

Les fonctions peuvent utiliser des objets comme paramètres (elles peuvent également fournir un objet comme valeur de retour). Par exemple, vous pouvez définir une fonction telle que celle-ci :

&lt;pre&gt;
&gt;&gt;&gt; def affiche_point(p):
        print &quot;coord. horizontale =&quot;, p.x, &quot;coord. verticale =&quot;, p.y
&lt;/pre&gt;

Le paramètre &lt;code&gt;p&lt;/code&gt; utilisé par cette fonction doit être un objet de type &lt;code&gt;Point()&lt;/code&gt;, puisque l'instruction qui suit utilise les variables d'instance &lt;code&gt;p.x&lt;/code&gt; et &lt;code&gt;p.y&lt;/code&gt;. Lorsqu'on appelle cette fonction, il faut donc lui fournir un objet de type &lt;code&gt;Point()&lt;/code&gt; comme argument. Essayons avec l'objet &lt;code&gt;p9&lt;/code&gt; :	

&lt;pre&gt;
&gt;&gt;&gt; affiche_point(p9)
coord. horizontale = 3.0 coord. verticale = 4.0
&lt;/pre&gt;

{{Exercices}}
# Écrivez une fonction &lt;code&gt;distance()&lt;/code&gt; qui permette de calculer la distance entre deux points. Cette fonction attendra évidemment deux objets &lt;code&gt;Point()&lt;/code&gt; comme arguments.
{{solution}}
#Réfléchissez !
{{fin}}


== Similitude et unicité ==

Dans la langue parlée, les mêmes mots peuvent avoir des significations fort différentes suivant le contexte dans lequel on les utilise. La conséquence en est que certaines expressions utilisant ces mots peuvent être comprises de plusieurs manières différentes (expressions ambiguës).

Le mot « même », par exemple, a des significations différentes dans les phrases : « Charles et moi avons la même voiture » et « Charles et moi avons la même mère ». Dans la première, ce que je veux dire est que la voiture de Charles et la mienne sont du même modèle. Il s'agit pourtant de deux voitures distinctes. Dans la seconde, j'indique que la mère de Charles et la mienne constituent en fait une seule et unique personne.

Lorsque nous traitons d'objets logiciels, nous pouvons rencontrer la même ambiguïté. Par exemple, si nous parlons de l'égalité de deux objets &lt;code&gt;Point()&lt;/code&gt;, cela signifie-t-il que ces deux objets contiennent les mêmes données (leurs attributs), ou bien cela signifie-t-il que nous parlons de deux références à un même et unique objet ?   Considérez par exemple les instructions suivantes :

&lt;pre&gt;
&gt;&gt;&gt; p1 = Point()
&gt;&gt;&gt; p1.x = 3
&gt;&gt;&gt; p1.y = 4
&gt;&gt;&gt; p2 = Point()
&gt;&gt;&gt; p2.x = 3
&gt;&gt;&gt; p2.y = 4
&gt;&gt;&gt; print (p1 == p2)
0
&lt;/pre&gt;

Ces instructions créent deux objets &lt;code&gt;p1&lt;/code&gt; et &lt;code&gt;p2&lt;/code&gt; qui restent distincts, même s'ils ont des contenus similaires. La dernière instruction teste l'égalité de ces deux objets (double signe égale), et le résultat est zéro (ce qui signifie que l'expression entre parenthèses est fausse : il n'y a donc pas égalité).

On peut confirmer cela d'une autre manière encore : 
&lt;pre&gt;
&gt;&gt;&gt; print p1
&lt;__main__.Point instance at 00C2CBEC&gt;
&gt;&gt;&gt; print p2
&lt;__main__.Point instance at 00C50F9C&gt;
&lt;/pre&gt;

L'information est claire :  les deux variables &lt;code&gt;p1&lt;/code&gt; et &lt;code&gt;p2&lt;/code&gt; référencent bien des objets différents.


Essayons autre chose, à présent : 

&lt;pre&gt;
&gt;&gt;&gt; p2 = p1
&gt;&gt;&gt; print (p1 == p2)
1
&lt;/pre&gt;

Par l'instruction &lt;code&gt;p2 = p1&lt;/code&gt;, nous assignons le contenu de &lt;code&gt;p1&lt;/code&gt; à &lt;code&gt;p2&lt;/code&gt;. Cela signifie que désormais ces deux variables référencent le même objet. Les variables &lt;code&gt;p1&lt;/code&gt; et &lt;code&gt;p2&lt;/code&gt; sont des alias l'une de l'autre.

Le test d'égalité dans l'instruction suivante renvoie cette fois la valeur 1, ce qui signifie que l'expression entre parenthèses est vraie : &lt;code&gt;p1&lt;/code&gt; et &lt;code&gt;p2&lt;/code&gt; désignent bien toutes deux un seul et unique objet, comme on peut s'en convaincre en essayant encore :

&lt;pre&gt;
&gt;&gt;&gt; p1.x = 7
&gt;&gt;&gt; print p2.x
7
&gt;&gt;&gt; print p1
&lt;__main__.Point instance at 00C2CBEC&gt;
&gt;&gt;&gt; print p2
&lt;__main__.Point instance at 00C2CBEC&gt;
&lt;/pre&gt;

== Objets composés d'objets ==

Supposons maintenant que nous voulions définir une classe pour représenter des rectangles. Pour simplifier, nous allons considérer que ces rectangles seront toujours orientés horizontalement ou verticalement, et jamais en oblique.

De quelles informations avons-nous besoin pour définir de tels rectangles ? Il existe plusieurs possibilités. Nous pourrions par exemple spécifier la position du centre du rectangle (deux coordonnées) et préciser sa taille (largeur et hauteur). Nous pourrions aussi spécifier les positions du coin supérieur gauche et du coin inférieur droit. Ou encore la position du coin supérieur gauche et la taille. Admettons ce soit cette dernière méthode qui soit retenue.

Définissons donc notre nouvelle classe :

&lt;pre&gt;
&gt;&gt;&gt; class Rectangle:
        &quot;définition d'une classe de rectangles&quot;
&lt;/pre&gt;

... et servons nous-en tout de suite pour créer une instance :

&lt;pre&gt;
&gt;&gt;&gt; boite = Rectangle()
&gt;&gt;&gt; boite.largeur = 50.0
&gt;&gt;&gt; boite.hauteur = 35.0
&lt;/pre&gt;

Nous créons ainsi un nouvel objet &lt;code&gt;Rectangle()&lt;/code&gt; et deux attributs. Pour spécifier le coin supérieur gauche, nous allons utiliser une instance de la classe &lt;code&gt;Point()&lt;/code&gt; que nous avons définie précédemment. Ainsi nous allons créer un objet à l'intérieur d'un autre objet !

&lt;pre&gt;
&gt;&gt;&gt; boite.coin = Point()
&gt;&gt;&gt; boite.coin.x = 12.0
&gt;&gt;&gt; boite.coin.y = 27.0
&lt;/pre&gt;

Pour accéder à un objet qui se trouve à l'intérieur d'un autre objet, on utilise la qualification des noms hiérarchisée (à l'aide de points) que nous avons déjà rencontrée à plusieurs reprises. Ainsi l'expression &lt;code&gt;boite.coin.y&lt;/code&gt; signifie « Aller à l'objet référencé dans la variable &lt;code&gt;boite&lt;/code&gt;. Dans cet objet, repérer l'attribut &lt;code&gt;coin&lt;/code&gt;, puis aller à l'objet référencé dans cet attribut. Une fois cet autre objet trouvé, sélectionner son attribut &lt;code&gt;y&lt;/code&gt;. » 

Vous pourrez peut-être mieux vous représenter à l'avenir les objets composites, à l'aide de diagrammes similaires à celui que nous reproduisons ci-dessous :

[[Image:Apprendre à programmer avec Python 35.png|center|400px|schéma de variables dans un contexte objet]]

Le nom « boîte » se trouve dans l'espace de noms principal. Il référence un autre espace de noms réservé à l'objet correspondant, dans lequel sont mémorisés les noms « largeur », « hauteur » et « coin ». Ceux-ci référencent à leur tour, soit d'autres espaces de noms (cas du nom « coin »), soit des valeurs bien déterminées. Python réserve des espaces de noms différents pour chaque module, chaque classe, chaque instance, chaque fonction. Vous pouvez tirer parti de tous ces espaces bien compartimentés afin de réaliser des programmes robustes, c'est-à-dire des programmes dont les différents composants ne peuvent pas facilement interférer.


== Objets comme valeurs de retour d'une fonction ==

Nous avons vu plus haut que les fonctions peuvent utiliser des objets comme paramètres. Elles peuvent également transmettre une instance comme valeur de retour. Par exemple, la fonction &lt;code&gt;trouveCentre()&lt;/code&gt; ci-dessous doit être appelée avec un argument de type &lt;code&gt;Rectangle()&lt;/code&gt; et elle renvoie un objet &lt;code&gt;Point()&lt;/code&gt;, lequel contiendra les coordonnées du centre du rectangle.

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; def trouveCentre(box):
        p = Point()
        p.x = box.coin.x + box.largeur/2.0
        p.y = box.coin.y + box.hauteur/2.0
        return p
&lt;/syntaxhighlight&gt;

Pour appeler cette fonction, vous pouvez utiliser l'objet boite comme argument :

&lt;pre&gt;
&gt;&gt;&gt; centre = trouveCentre(boite)
&gt;&gt;&gt; print centre.x, centre.y
37.0  44.5
&lt;/pre&gt;

== Les objets sont modifiables ==

Nous pouvons changer les propriétés d'un objet en assignant de nouvelles valeurs à ses attributs. Par exemple, nous pouvons modifier la taille d'un rectangle (sans modifier sa position), en réassignant ses attributs hauteur et largeur :

&lt;pre&gt;
&gt;&gt;&gt; boite.hauteur = boite.hauteur + 20
&gt;&gt;&gt; boite.largeur = boite.largeur – 5
&lt;/pre&gt;

Nous pouvons faire cela sous Python, parce que dans ce langage les propriétés des objets sont toujours publiques (du moins dans la version actuelle 2.0). D'autres langages établissent une distinction nette entre attributs publics (accessibles de l'extérieur de l'objet) et attributs privés (qui sont accessibles seulement aux algorithmes inclus dans l'objet lui-même).

Comme nous l'avons déjà signalé plus haut (à propos de la définition des attributs par assignation simple, depuis l'extérieur de l'objet), ''modifier de cette façon les attributs d'une instance n'est pas une pratique recommandable'', parce qu'elle contredit l'un des objectifs fondamentaux de la programmation orientée objet, qui vise à établir une séparation stricte entre la fonctionnalité d'un objet (telle qu'elle a été déclarée au monde extérieur) et la manière dont cette fonctionnalité est réellement implémentée dans l'objet (et que le monde extérieur n'a pas à connaître).

Plus concrètement, nous devrons veiller désormais à ce que les objets que nous créons ne soient modifiables en principe que par l'intermédiaire de méthodes mises en place spécifiquement dans ce but, comme nous allons l'expliquer dans le chapitre suivant.


== Définition d'une méthode ==

Pour illustrer notre propos, nous allons définir une nouvelle classe ''Time'', qui nous permettra d'effectuer toute une série d'opérations sur des instants, des durées, etc. :

&lt;pre&gt;
&gt;&gt;&gt; class Time:
        &quot;Définition d'une classe temporelle&quot;
&lt;/pre&gt;

Créons à présent un objet de ce type, et ajoutons-lui des variables d'instance pour mémoriser les heures, minutes et secondes :

&lt;pre&gt;
&gt;&gt;&gt; instant = Time()
&gt;&gt;&gt; instant.heure = 11
&gt;&gt;&gt; instant.minute = 34
&gt;&gt;&gt; instant.seconde = 25
&lt;/pre&gt;

À titre d'exercice, écrivez maintenant vous-même une fonction &lt;code&gt;affiche_heure()&lt;/code&gt;, qui serve à visualiser le contenu d'un objet de classe &lt;code&gt;Time()&lt;/code&gt; sous la forme conventionnelle « heure:minute:seconde ».

Appliquée à l'objet &lt;code&gt;instant&lt;/code&gt; créé ci-dessus, cette fonction devrait donc afficher &lt;code&gt;11:34:25&lt;/code&gt; :

&lt;pre&gt;
&gt;&gt;&gt; print affiche_heure(instant)
11:34:25
&lt;/pre&gt;

Votre fonction ressemblera probablement à ceci :

&lt;pre&gt;
&gt;&gt;&gt; def affiche_heure(t):
        print str(t.heure) + &quot;:&quot; + str(t.minute) + &quot;:&quot; + str(t.seconde)
&lt;/pre&gt;

(Notez au passage l'utilisation de la fonction &lt;code&gt;str()&lt;/code&gt; pour convertir les données numériques en chaînes de caractères).  Si par la suite vous utilisez fréquemment des objets de la classe &lt;code&gt;Time()&lt;/code&gt;, il y a gros à parier que cette fonction d'affichage vous sera fréquemment utile.

Il serait donc probablement fort judicieux ''d'encapsuler'' cette fonction &lt;code&gt;affiche_heure()&lt;/code&gt; dans la classe &lt;code&gt;Time()&lt;/code&gt; elle-même, de manière à s'assurer qu'elle soit toujours automatiquement disponible chaque fois que l'on doit manipuler des objets de la classe &lt;code&gt;Time()&lt;/code&gt;.

Une fonction qui est ainsi encapsulée dans une classe s'appelle une ''méthode''.


;Définition concrète d'une méthode

On définit une méthode comme on définit une fonction, avec cependant deux différences :

&lt;ul&gt;
&lt;li&gt;''La définition d'une méthode est toujours placée à l'intérieur de la définition d'une classe'', de manière à ce que la relation qui lie la méthode à la classe soit clairement établie.&lt;/li&gt;

&lt;li&gt;Le premier paramètre utilisé par une méthode doit toujours être une référence d'instance.

Vous pourriez en principe utiliser un nom de variable quelconque pour ce paramètre, mais il est vivement conseillé de respecter la convention qui consiste à toujours lui donner le nom &lt;code&gt;self&lt;/code&gt;.

Le paramètre &lt;code&gt;self&lt;/code&gt; désigne donc l'instance à laquelle la méthode sera associée, dans les instructions faisant partie de la définition. (De ce fait, la définition d'une méthode comporte toujours au moins un paramètre, alors que la définition d'une fonction peut n'en comporter aucun).&lt;/li&gt;
&lt;/ul&gt;

Voyons comment cela se passe en pratique :

Pour ré-écrire la fonction &lt;code&gt;affiche_heure()&lt;/code&gt; comme une méthode de la classe &lt;code&gt;Time()&lt;/code&gt;, il nous suffit de déplacer sa définition à l'intérieur de celle de la classe, et de changer le nom de son paramètre :

&lt;pre&gt;
&gt;&gt;&gt; class Time:
        &quot;Nouvelle classe temporelle&quot;
        def affiche_heure(self):
            print str(self.heure) + &quot;:&quot; + str(self.minute) \
                  + &quot;:&quot; + str(self.seconde)
&lt;/pre&gt;

La définition de la méthode fait maintenant partie du bloc d'instructions indentées après l'instruction &lt;code&gt;class&lt;/code&gt;.  Notez bien l'utilisation du mot réservé &lt;code&gt;self&lt;/code&gt;, qui se réfère donc à toute instance susceptible d'être créée à partir de cette classe.


;Essai de la méthode dans une instance

Nous pouvons dès à présent instancier un objet de notre nouvelle classe Time() :

&lt;pre&gt;
&gt;&gt;&gt; maintenant = Time()
&lt;/pre&gt;

Si nous essayons d'utiliser un peu trop vite notre nouvelle méthode, ça ne marche pas :

&lt;pre&gt;
&gt;&gt;&gt; maintenant.affiche_heure()
AttributeError: 'Time' instance has no attribute 'heure'
&lt;/pre&gt;

C'est normal : nous n'avons pas encore créé les attributs d'instance. Il faudrait faire par exemple :

&lt;pre&gt;
&gt;&gt;&gt; maintenant.heure = 13
&gt;&gt;&gt; maintenant.minute = 34
&gt;&gt;&gt; maintenant.seconde = 21
&gt;&gt;&gt; maintenant.affiche_heure()
13:34:21
&lt;/pre&gt;

Nous avons cependant déjà signalé à plusieurs reprises qu'il n'est pas recommandable de créer ainsi les attributs d'instance en dehors de l'objet lui-même, ce qui conduit (entre autres désagréments) à des erreurs comme celle que nous venons de rencontrer, par exemple.

Voyons donc à présent comment nous pouvons mieux faire.

== Méthodes prédéfinies ==
Certaines méthodes de classe Python existent automatiquement dans toutes les classes sans être déclarées, et certaines se lancent automatiquement lors de certains événements. Ces méthodes spéciales sont nommées entre deux underscores (__)&lt;ref&gt;https://docs.python.org/2.7/reference/datamodel.html#special-method-names&lt;/ref&gt;.


=== __doc__ ===
Comme pour les fonctions, la chaîne de documentation est définie dans cette méthode.

&lt;pre&gt;
&gt;&gt;&gt; print p9.__doc__
Définition d'un point mathématique
&lt;/pre&gt;

Dans le cas d'un module, la doc correspond au premier bloc de commentaire :
 &quot;&quot;&quot;Définition d'un point mathématique&quot;&quot;&quot;

=== __contains__ ===
Cette méthode permet de lancer des recherches dans une classes comme dans un objet composite comme la liste, avec &quot;in&quot;. En effet, il suffit d'y placer les getters sur les attributs :

&lt;syntaxhighlight lang=python&gt;
class MyClass:
    attribute1 = 'ok'

    def __contains__(self, attribute):
        if self.attribute1: return True

MaClasse1 = MyClass()
print attribute1 in MaClasse1 # True
print attribute2 in MaClasse1 # False
&lt;/syntaxhighlight&gt;

=== __del__ ===
Destructeur : se lance quand l'objet est détruit.


=== __enter__ et __exit__ ===
Respectivement constructeur et destructeur des classes instanciées avec &lt;code&gt;with&lt;/code&gt;, exécutés respectivement après et avant &lt;code&gt;__init__&lt;/code&gt; et &lt;code&gt;__del__&lt;/code&gt;. Exemple :
&lt;syntaxhighlight lang=python&gt;
class Test:        
    def __enter__(self):
        print 'enter'
     
    def __exit__(self, exc_type, exc_value, traceback):
        print 'exit'

with Test():
    pass
&lt;/syntaxhighlight&gt;
 enter
 exit


=== __ init __ ===
Cette méthode se lance lors du premier accès à la classe.

Exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
class Complexe:
	def __init__(self, r, i):
		self.reel = r
		self.imaginaire = i

Complexe1 = Complexe(1, 2)
print Complexe1.reel    # Affiche 1
&lt;/syntaxhighlight&gt;


L'erreur que nous avons rencontrée au paragraphe précédent est-elle évitable ? Elle ne se produirait effectivement pas, si nous nous étions arrangés pour que la méthode &lt;code&gt;affiche_heure()&lt;/code&gt; puisse toujours afficher quelque chose, sans qu'il ne soit nécessaire d'effectuer au préalable aucune manipulation sur l'objet nouvellement créé. En d'autres termes, ''il serait judicieux que les variables d'instance soient prédéfinies elles aussi à l'intérieur de la classe'', avec pour chacune d'elles une valeur « par défaut ».

Pour obtenir cela, nous allons faire appel à une méthode particulière, que l'on appelle un constructeur. Une méthode constructeur est une méthode qui est exécutée automatiquement lorsque l'on instancie un nouvel objet à partir de la classe. On peut y placer tout ce qui semble nécessaire pour initialiser automatiquement l'objet que l'on crée.

Exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; class Time:
        &quot;Encore une nouvelle classe temporelle&quot;
        def __init__(self):
            self.heure =0
            self.minute =0
            self.seconde =0

        def affiche_heure(self):
            print str(self.heure) + &quot;:&quot; + str(self.minute) \
                 + &quot;:&quot; + str(self.seconde)

&gt;&gt;&gt; tstart = Time()
&gt;&gt;&gt; tstart.affiche_heure()
0:0:0
&lt;/syntaxhighlight&gt;

L'intérêt de cette technique apparaîtra plus clairement si nous ajoutons encore quelque chose. Comme toute méthode qui se respecte, la méthode &lt;code&gt;__init__()&lt;/code&gt; peut être dotée de paramètres. Ceux-ci vont jouer un rôle important, parce qu'ils vont permettre d'instancier un objet et d'initialiser certaines de ses variables d'instance, en une seule opération. Dans l'exemple ci-dessus, veuillez donc modifier la définition de la méthode &lt;code&gt;__init__()&lt;/code&gt; comme suit :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
        def __init__(self, hh =0, mm =0, ss =0):
            self.heure = hh
            self.minute = mm
            self.seconde = ss
&lt;/syntaxhighlight&gt;

La méthode &lt;code&gt;__init__()&lt;/code&gt; comporte à présent 3 paramètres, avec pour chacun une valeur par défaut. Pour lui transmettre les arguments correspondants, il suffit de placer ceux-ci dans les parenthèses qui accompagnent le nom de la classe, lorsque l'on écrit l'instruction d'instanciation du nouvel objet.

Voici par exemple la création et l'initialisation simultanées d'un nouvel objet &lt;code&gt;Time()&lt;/code&gt; :

&lt;pre&gt;
&gt;&gt;&gt; recreation = Time(10, 15, 18)
&gt;&gt;&gt; recreation.affiche_heure()
10:15:18
&lt;/pre&gt;

Puisque les variables d'instance possèdent maintenant des valeurs par défaut, nous pouvons aussi bien créer de tels objets Time() en omettant un ou plusieurs arguments :

&lt;pre&gt;
&gt;&gt;&gt; rentree = Time(10, 30)
&gt;&gt;&gt; rentree.affiche_heure()
10:30:0
&lt;/pre&gt;

=== __main__ ===
&lt;pre&gt;
&gt;&gt;&gt; print p9
&lt;__main__.Point instance at 0x403e1a8c&gt;
&lt;/pre&gt;

Le message renvoyé par Python indique, comme vous l'aurez certainement bien compris tout de suite, que &quot;p9&quot; est une instance de la classe &quot;Point()&quot;, qui est définie elle-même au niveau principal du programme. Elle est située dans un emplacement bien déterminé de la mémoire vive, dont l'adresse apparaît ici en notation {{wt|hexadécimal}}e.


=== __new__ ===

Constructeur de {{w|métaclasse}}.

La méthode &lt;code&gt;__new__&lt;/code&gt; est statique.
Elle est appelée pour créer l'objet instancié avec l'opérateur &lt;code&gt;new&lt;/code&gt;, juste avant l'appel à la méthode &lt;code&gt;__init__&lt;/code&gt; initialisant les membres de l'objet créé.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
__new__(class, *args, **kwargs)
&lt;/syntaxhighlight&gt;

Les arguments de la méthode &lt;code&gt;__new__&lt;/code&gt; sont décris ci-après :
;&lt;code&gt;class&lt;/code&gt;:Le premier argument est la classe de l'objet à créer.
;&lt;code&gt;args&lt;/code&gt;:Liste itérable des arguments non nommés à transmettre au constructeur.
;&lt;code&gt;kwargs&lt;/code&gt;:Dictionnaire des arguments nommés à transmettre au constructeur.

La méthode retourne l'objet créé.
Comme cette méthode est héritée de la classe &lt;code&gt;object&lt;/code&gt;, une classe peut la surcharger en appelant celle de la classe parente (&lt;syntaxhighlight lang=&quot;python&quot; inline&gt;super().__new__()&lt;/syntaxhighlight&gt;) avec des arguments modifiés, ou pour exécuter des actions avant ou après la création d'un objet.

Techniquement, la méthode &lt;syntaxhighlight lang=&quot;python&quot; inline&gt;object.__new__()&lt;/syntaxhighlight&gt; peut être appelée pour créer un objet, mais il faut ensuite appeler manuellement la méthode &lt;syntaxhighlight lang=&quot;python&quot; inline&gt;__init__()&lt;/syntaxhighlight&gt; sur l'objet créé.
Cet enchaînement des deux appels n'est fait que par l'opérateur &lt;code&gt;new&lt;/code&gt;.

Exemple : Une classe héritant de celle des entiers pour créer des cubes d'entier.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
class CubeEntier(int):
    def __new__(cls, value):
        return super().__new__(cls, value ** 3)

x = CubeEntier(3)
print(x)  # 27
&lt;/syntaxhighlight&gt;

=== __repr__ ===
Cette méthode renvoie une représentation de l'objet quand on l'appelle directement (sans chercher à accéder à ses attributs ou méthodes). Exemple :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
class Bar:
    def __init__ (self, iamthis):
        self.iamthis = iamthis

    def __repr__(self):
        return &quot;Bar('%s')&quot; % self.iamthis

bar = Bar('apple')
print bar
&lt;/syntaxhighlight&gt;
 Bar('apple')

Dans cette méthode, cet objet renverrait :
 &lt;__main__.Bar instance at 0x7f282bbf2a28&gt;


=== __str__ ===
Renvoie une chaine de caractères quand on traite l'objet comme tel. Exemple :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
class Bar:
    def __init__ (self, iam_this):
        self.iam_this = iam_this

    def __str__ (self):
        return self.iam_this

bar = Bar('apple')
print bar
&lt;/syntaxhighlight&gt;

 apple


=== __unicode__ ===
Réservé à Python 2.x.


=== Opérateurs binaires ===

{| class=&quot;wikitable&quot;
! Fonction
! Opérateur
|-
| __add__ || A + B
|-
| __sub__ || A - B
|-
| __mul__ || A * B
|-
| __truediv__ || A / B
|-
| __floordiv__ || A // B
|-
| __mod__ || A % B
|-
| __pow__ || A ** B
|-
| __and__ || A &amp; B
|-
| __or__ || &lt;nowiki&gt;A | B&lt;/nowiki&gt;
|-
| __xor__ || A ^ B
|-
| __eq__ || A == B
|-
| __ne__ || A != B
|-
| __gt__ || A &gt; B
|-
| __lt__ || A &lt; B
|-
| __ge__ || A &gt;= B
|-
| __le__ || A &lt;= B
|-
| __lshift__ || A &lt;&lt; B
|-
| __rshift__ || A &gt;&gt; B
|-
| __contains__ || A in B&lt;br/&gt;A not in B
|}


=== Opérateurs unaires ===
{| class=&quot;wikitable&quot;
! Fonction
! Opérateur
|-
| __pos__ || +A
|-
| __neg__ || -A
|-
| __inv__ || ~A
|-
| __abs__ || abs(A)
|-
| __len__ || len(A)
|}


=== Gestion des attributs ===
{{wt|getter|Getters}} et {{wt|setter|setters}}.

{| class=&quot;wikitable&quot;
! Fonction
! Forme indirecte
! Forme directe
|-
| __getattr__ || getattr(A, B) || A.B
|-
| __setattr__ || setattr(A, B, C) || A.B = C
|-
| __delattr__ || delattr(A, B) || del A.B
|}

=== Gestion des indices ===
Se déclenchent lorsque l'on manipule un objet comme un dictionnaire&lt;ref&gt;http://farmdev.com/src/secrets/magicmethod/&lt;/ref&gt;.

{| class=&quot;wikitable&quot;
! Fonction
! Opérateur
|-
| __getitem__ || C[i]
|-
| __setitem__ || C[i] = v
|-
| __delitem__ || del C[i]
|-
| __getslice__ || C[s:e]
|-
| __setslice__ || C[s:e] = v
|-
| __delslice__ || del C[s:e]
|}


=== Divers ===
{| class=&quot;wikitable&quot;
! Fonction
! Opérateur
|-
| __cmp__ || cmp(x, y)
|-
| __hash__ || hash(x)
|-
| __nonzero__ || bool(x)
|-
| __call__ || f(x)
|-
| __iter__ || iter(x)
|-
| __reversed__ || reversed(x) (2.6+)
|-
| __divmod__ || divmod(x, y)
|-
| __int__ || int(x)
|-
| __long__ || long(x)
|-
| __float__ || float(x)
|-
| __complex__ || complex(x)
|-
| __hex__ || hex(x)
|-
| __oct__ || oct(x)
|-
| __index__ || 
|-
| __copy__ || copy.copy(x)
|-
| __deepcopy__ || copy.deepcopy(x)
|-
| __sizeof__ || sys.getsizeof(x) (2.6+)
|-
| __trunc__ || math.trunc(x) (2.6+)
|-
| __format__ || format(x, ...) (2.6+)
|}


== Espaces de noms des classes et instances ==

Les variables définies à l'intérieur d'une fonction sont des variables locales, inaccessibles aux instructions qui se trouvent à l'extérieur de la fonction. Cela permet d'utiliser les mêmes noms de variables dans différentes parties d'un programme, sans risque d'interférence.

Pour décrire la même chose en d'autres termes, nous pouvons dire que chaque fonction possède son propre ''{{w|espace de noms}}'', indépendant de l'espace de noms principal.

Les instructions se trouvant à l'intérieur d'une fonction peuvent accéder aux variables définies au niveau principal, mais ''en lecture seulement'' : elles peuvent utiliser les valeurs de ces variables, mais pas les modifier (à moins de faire appel à l'instruction &lt;code&gt;global&lt;/code&gt;).

Il existe donc une sorte de hiérarchie entre les espaces de noms. Nous allons constater la même chose à propos des classes et des objets. En effet :

* Chaque classe possède son propre espace de noms. Les variables qui en font partie sont appelées les attributs de la classe.

* Chaque objet instance (créé à partir d'une classe) obtient son propre espace de noms. Les variables qui en font partie sont appelées variables d'instance ou attributs d'instance.

* Les classes peuvent utiliser (mais pas modifier) les variables définies au niveau  principal.

* Les instances peuvent utiliser (mais pas modifier) les variables définies au niveau de la classe et les variables définies au niveau principal.

Considérons par exemple la classe &lt;code&gt;Time()&lt;/code&gt; définie précédemment. À la page précédente, nous avons instancié deux objets de cette classe : &lt;code&gt;recreation&lt;/code&gt; et &lt;code&gt;rentree&lt;/code&gt;. Chacun a été initialisé avec des valeurs différentes, indépendantes. Nous pouvons modifier et réafficher ces valeurs à volonté dans chacun de ces deux objets, sans que l'autre n'en soit affecté :

&lt;pre&gt;
&gt;&gt;&gt; recreation.heure = 12
&gt;&gt;&gt; rentree.affiche_heure()
10:30:0
&gt;&gt;&gt; recreation.affiche_heure()
12:15:18
&lt;/pre&gt;

Veuillez à présent encoder et tester l'exemple ci-dessous :    

&lt;pre&gt;
&gt;&gt;&gt; class Espaces:                          # 1
        aa = 33                             # 2
        def affiche(self):                  # 3
            print aa, Espaces.aa, self.aa   # 4

&gt;&gt;&gt; aa = 12                                 # 5
&gt;&gt;&gt; essai = Espaces()                       # 6
&gt;&gt;&gt; essai.aa = 67                           # 7
&gt;&gt;&gt; essai.affiche()                         # 8
12 33 67
&gt;&gt;&gt; print aa, Espaces.aa, essai.aa          # 9
12 33 67
&lt;/pre&gt;

Dans cet exemple, le même nom aa est utilisé pour définir trois variables différentes : une dans l'espace de noms de la classe (à la ligne 2), une autre dans l'espace de noms principal (à la ligne 5), et enfin une dernière dans l'espace de nom de l'instance (à la ligne 7).

La ligne 4 et la ligne 9 montrent comment vous pouvez accéder à ces trois espaces de noms (de l'intérieur d'une classe, ou au niveau principal), en utilisant la qualification par points. Notez encore une fois l'utilisation de &lt;code&gt;self&lt;/code&gt; pour désigner l'instance.

== Héritage ==

Les classes constituent le principal outil de la [[programmation orientée objet]] ou POO (''Object Oriented Programming ou OOP'' en anglais), qui est considérée de nos jours comme la technique de programmation la plus performante. L'un des principaux atouts de ce type de programmation réside dans le fait que l'on peut toujours se servir d'une classe préexistante pour en créer une nouvelle qui possédera quelques fonctionnalités différentes ou supplémentaires. Le procédé s'appelle ''dérivation''. Il permet de créer toute une hiérarchie de classes allant du général au particulier.

Nous pouvons par exemple définir une classe &lt;code&gt;Mammifere()&lt;/code&gt;, qui contiendra un ensemble de caractéristiques propres à ce type d'animal. À partir de cette classe, nous pourrons alors dériver une classe &lt;code&gt;Primate()&lt;/code&gt;, une classe &lt;code&gt;Rongeur()&lt;/code&gt;, une classe &lt;code&gt;Carnivore()&lt;/code&gt;, etc., qui hériteront toutes des caractéristiques de la classe Mammifere(), en y ajoutant leurs spécificités.

Au départ de la classe Carnivore(), nous pourrons ensuite dériver une classe Belette(), une classe Loup(), une classe Chien(), etc., qui ''hériteront'' encore une fois toutes les caractéristiques de la classe &lt;code&gt;Mammifere&lt;/code&gt; avant d'y ajouter les leurs. Exemple :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; class Mammifere:
        caract1 = &quot;il allaite ses petits ;&quot;

&gt;&gt;&gt; class Carnivore(Mammifere):
        caract2 = &quot;il se nourrit de la chair de ses proies ;&quot;

&gt;&gt;&gt; class Chien(Carnivore):
        caract3 = &quot;son cri s'appelle aboiement ;&quot;

&gt;&gt;&gt; mirza = Chien()
&gt;&gt;&gt; print mirza.caract1, mirza.caract2, mirza.caract3
&lt;/syntaxhighlight&gt;
 il allaite ses petits ; il se nourrit de la chair de ses proies ;
 son cri s'appelle aboiement ;

Dans cet exemple, nous voyons que l'objet &lt;code&gt;mirza&lt;/code&gt;, qui est une instance de la classe &lt;code&gt;Chien()&lt;/code&gt;, hérite non seulement l'attribut défini pour cette classe, mais également  des attributs définis pour les classes parentes.

Vous voyez également dans cet exemple comment il faut procéder pour dériver une classe à partir d'une classe parente : On utilise l'instruction &lt;code&gt;class&lt;/code&gt;, suivie comme d'habitude du nom que l'on veut attribuer à la nouvelle classe, ''et on place entre parenthèses le nom de la classe parente''.

Notez bien que les attributs utilisés dans cet exemple sont des attributs des classes (et non des attributs d'instances). L'instance &lt;code&gt;mirza&lt;/code&gt; peut accéder à ces attributs, mais pas les modifier :

&lt;syntaxhighlight lang=python line&gt;
&gt;&gt;&gt; mirza.caract2 = &quot;son corps est couvert de poils&quot;
&gt;&gt;&gt; print mirza.caract2
son corps est couvert de poils
&gt;&gt;&gt; fido = Chien()
&gt;&gt;&gt; print fido.caract2
il se nourrit de la chair de ses proies ;
&lt;/syntaxhighlight&gt;

Dans ce nouvel exemple, la ligne 1 ne modifie pas l'attribut &lt;code&gt;caract2&lt;/code&gt; de la classe &lt;code&gt;Carnivore()&lt;/code&gt;, contrairement à ce que l'on pourrait penser au vu de la ligne 3.  Nous pouvons le vérifier en créant une nouvelle instance &lt;code&gt;fido&lt;/code&gt; (lignes 4 à 6).

Si vous avez bien assimilé les paragraphes précédents, vous aurez compris que l'instruction de la ligne 1 crée une nouvelle variable d'instance associée seulement à l'objet &lt;code&gt;mirza&lt;/code&gt;. Il existe donc dès ce moment deux variables avec le même nom &lt;code&gt;caract2&lt;/code&gt; : l'une dans l'espace de noms de l'objet &lt;code&gt;mirza&lt;/code&gt;, et l'autre dans l'espace de noms de la classe &lt;code&gt;Carnivore()&lt;/code&gt;.

Comment faut-il alors interpréter ce qui s'est passé aux lignes 2 et 3 ?  Comme nous l'avons vu plus haut, l'instance &lt;code&gt;mirza&lt;/code&gt; peut accéder aux variables situées dans son propre espace de noms, mais aussi à celles qui sont situées dans les espaces de noms de toutes les classes parentes. S'il existe des variables aux noms identiques dans plusieurs de ces espaces, laquelle sera-t-elle sélectionnée lors de l'exécution d'une instruction comme celle de la ligne 2 ?

Pour résoudre ce conflit, Python respecte une règle de priorité fort simple. Lorsqu'on lui demande d'utiliser la valeur d'une variable nommée ''alpha'', par exemple, il commence par rechercher ce nom dans l'espace local (le plus « interne », en quelque sorte). Si une variable ''alpha'' est trouvée dans l'espace local, c'est celle-là qui est utilisée, et la recherche s'arrête. Sinon, Python examine l'espace de noms de la structure parente, puis celui de la structure grand-parente, et ainsi de suite jusqu'au niveau principal du programme.

À la ligne 2 de notre exemple, c'est donc la variable d'instance qui sera utilisée. À la ligne 5, par contre, c'est seulement au niveau de la classe grand-parente qu'une variable répondant au nom &lt;code&gt;caract2&lt;/code&gt; peut être trouvée. C'est donc celle-là qui est affichée.

== Héritage et polymorphisme ==

Pour bien comprendre ce script, il faut cependant d'abord vous rappeler quelques notions élémentaires de chimie.  Dans votre cours de ''chimie'', vous avez certainement dû apprendre que les ''atomes'' sont des entités constituées d'un certain nombre de ''protons'' (particules chargées d'électricité positive), d'''électrons'' (chargés négativement) et de ''neutrons'' (neutres).

Le type d'atome (ou élément) est déterminé par le nombre de protons, que l'on appelle également ''numéro atomique''. Dans son état fondamental, un atome contient autant d'électrons que de protons, et par conséquent il est électriquement neutre. Il possède également un nombre variable de neutrons, mais ceux-ci n'influencent en aucune manière la charge électrique globale.

Dans certaines circonstances, un atome peut gagner ou perdre des électrons. Il acquiert de ce fait une charge électrique globale, et devient alors un ''ion'' (il s'agit d'un ''ion négatif'' si l'atome a gagné un ou plusieurs électrons, et d'un ''ion positif'' s'il en a perdu). La charge électrique d'un ion est égale à la différence entre le nombre de protons et le nombre d'électrons qu'il contient.

Le script suivant génère des objets &lt;code&gt;atome&lt;/code&gt; et des objets &lt;code&gt;ion&lt;/code&gt;. Nous avons rappelé ci-dessus qu'un ion est simplement un atome modifié. Dans notre programmation, la classe qui définit les objets « ion » sera donc une classe dérivée de la classe &lt;code&gt;atome&lt;/code&gt; : elle héritera d'elle tous ses attributs et toutes ses méthodes, en y ajoutant les siennes propres. On pourra dire également que la méthode &lt;code&gt;affiche()&lt;/code&gt; a été surchargée.

L'une de ces méthodes ajoutées (la méthode &lt;code&gt;affiche()&lt;/code&gt;) remplace une méthode de même nom héritée de la classe &lt;code&gt;atome&lt;/code&gt;. Les classes « atome » et « ion » possèdent donc chacune une méthode de même nom, mais qui effectuent un travail différent. On parle dans ce cas de polymorphisme. On pourra dire également que la méthode &lt;code&gt;affiche()&lt;/code&gt; a été ''surchargée''.&lt;!-- répétition voulue ou erreur dans le livre ? --&gt;

Il sera évidemment possible d'instancier un nombre quelconque d'atomes et d'ions à partir de ces deux classes. Or l'une d'entre elles (la classe &lt;code&gt;atome&lt;/code&gt;) doit contenir une version simplifiée du tableau périodique des éléments (tableau de Mendeleïev), de façon à pouvoir attribuer un nom d'élément chimique, ainsi qu'un nombre de neutrons, à chaque objet généré. Comme il n'est pas souhaitable de recopier tout ce tableau dans chacune des instances, nous le placerons dans ''un attribut de classe''. Ainsi ce tableau n'existera qu'en un seul endroit en mémoire, tout en restant accessible à tous les objets qui seront produits à partir de cette classe.

Voyons concrètement comment toutes ces idées s'articulent :

&lt;syntaxhighlight lang=python&gt;
class Atome:
    &quot;&quot;&quot;atomes simplifiés, choisis parmi les 10 premiers éléments du TP&quot;&quot;&quot; 
    table = [None, ('hydrogène',0), ('hélium',2), ('lithium',4),
            ('béryllium',5), ('bore',6), ('carbone',6), ('azote',7),
            ('oxygène',8), ('fluor',10), ('néon',10)]
            
    def __init__(self, nat):
        &quot;le n° atomique détermine le n. de protons, d'électrons et de neutrons&quot; 
        self.np, self.ne = nat, nat       # nat = numéro atomique
        self.nn = Atome.table[nat][1]     # nb. de neutrons trouvés dans table
        
    def affiche(self):
        print
        print &quot;Nom de l'élément :&quot;, Atome.table[self.np][0]
        print &quot;%s protons, %s électrons, %s neutrons&quot; % \
                  (self.np, self.ne, self.nn)
               
class Ion(Atome):
    &quot;&quot;&quot;les ions sont des atomes qui ont gagné ou perdu des électrons&quot;&quot;&quot;
     
    def __init__(self, nat, charge):
        &quot;le n° atomique et la charge électrique déterminent l'ion&quot;
        Atome.__init__(self, nat)
        self.ne = self.ne - charge
        self.charge = charge
    
    def affiche(self):
        &quot;cette méthode remplace celle héritée de la classe parente&quot; 
        Atome.affiche(self)			# ... tout en l'utilisant elle-même ! 
        print &quot;Particule électrisée. Charge =&quot;, self.charge        
        
### Programme principal : ###     

a1 = Atome(5)
a2 = Ion(3, 1)
a3 = Ion(8, -2)
a1.affiche()
a2.affiche()
a3.affiche()
&lt;/syntaxhighlight&gt;

L'exécution de ce script provoque l'affichage suivant :

&lt;pre&gt;
Nom de l'élément : bore
5 protons, 5 électrons, 6 neutrons

Nom de l'élément : lithium
3 protons, 2 électrons, 4 neutrons
Particule électrisée. Charge = 1

Nom de l'élément : oxygène
8 protons, 10 électrons, 8 neutrons
Particule électrisée. Charge = -2
&lt;/pre&gt;

Au niveau du programme principal, vous pouvez constater que l'on instancie les objets &lt;code&gt;Atome()&lt;/code&gt; en fournissant leur numéro atomique (lequel doit être compris entre 1 et 10). Pour instancier des objets &lt;code&gt;Ion()&lt;/code&gt;, par contre, on doit fournir un numéro atomique et une charge électrique globale (positive ou négative). La même méthode &lt;code&gt;affiche()&lt;/code&gt; fait apparaître les propriétés de ces objets, qu'il s'agisse d'atomes ou d'ions, avec dans le cas de l'ion une ligne supplémentaire (polymorphisme).

;Commentaires

La définition de la classe &lt;code&gt;Atome()&lt;/code&gt; commence par l'assignation de la variable &lt;code&gt;table&lt;/code&gt;. Une variable définie à cet endroit fait partie de l'espace de noms de la classe. C'est donc un ''attribut de classe'', dans lequel nous plaçons une liste d'informations concernant les 10 premiers éléments du tableau périodique de Mendeleïev.
Pour chacun de ces éléments, la liste contient un tuple : (nom de l'élément, nombre de neutrons), à l'indice qui correspond au numéro atomique. Comme il n'existe pas d'élément de numéro atomique zéro, nous avons placé à l'indice zéro dans la liste, l'objet spécial &lt;code&gt;None&lt;/code&gt; (''a priori'', nous aurions pu placer à cet endroit n'importe quelle autre valeur, puisque cet indice ne sera pas utilisé. L'objet &lt;code&gt;None&lt;/code&gt; de Python nous semble cependant particulièrement explicite).

Viennent ensuite les définitions de deux méthodes :

* Le constructeur &lt;code&gt;__init__()&lt;/code&gt; sert essentiellement ici à générer trois ''attributs d'instance'', destinés à  mémoriser respectivement les nombres de protons, d'électrons et de neutrons pour chaque objet atome construit à partir de cette classe (Les attributs d'instance sont des variables liées à &lt;code&gt;self&lt;/code&gt;).
Notez bien la technique utilisée pour obtenir le nombre de neutrons à partir de l'attribut de classe, en mentionnant le nom de la classe elle-même dans une qualification par points.

* La méthode &lt;code&gt;affiche()&lt;/code&gt; utilise à la fois les attributs d'instance, pour retrouver les nombres de protons, d'électrons et de neutrons de l'objet courant, et l'attribut de classe (lequel est commun à tous les objets) pour en extraire le nom d'élément correspondant. Veuillez aussi remarquer au passage l'utilisation de la technique de formatage des chaînes.

La définition de la classe &lt;code&gt;Ion()&lt;/code&gt; comporte des parenthèses. Il s'agit donc d'une ''classe dérivée'', sa ''classe parente'' étant bien entendu la classe &lt;code&gt;Atome()&lt;/code&gt; qui précède.

Les méthodes de cette classe sont des variantes de celles de la classe &lt;code&gt;Atome()&lt;/code&gt;. Elles devront donc vraisemblablement faire appel à celles-ci. Cette remarque est importante :

{{remarque|Comment peut-on, à l'intérieur de la définition d'une classe, faire appel à une méthode définie dans une autre classe ?}}

Il ne faut pas perdre de vue, en effet, qu'une méthode se rattache toujours à l'instance qui sera générée à partir de la classe (instance représentée par &lt;code&gt;self&lt;/code&gt; dans la définition). Si une méthode doit faire appel à une autre méthode définie dans une autre classe, il faut pouvoir lui transmettre la référence de l'instance à laquelle elle doit s'associer. Comment faire ? C'est très simple :

{{remarque|Lorsque dans la définition d'une classe, on souhaite faire appel à une méthode définie dans une autre classe, on doit lui transmettre la référence de l'instance comme premier argument.}}

C'est ainsi que dans notre script, par exemple, la méthode &lt;code&gt;affiche()&lt;/code&gt; de la classe &lt;code&gt;Ion()&lt;/code&gt; peut faire appel à la méthode &lt;code&gt;affiche()&lt;/code&gt; de la classe &lt;code&gt;Atome()&lt;/code&gt; : les informations affichées seront bien celles de l'objet-ion courant, puisque sa référence a été transmise dans l'instruction d'appel :

&lt;pre&gt;
Atome.affiche(self)
&lt;/pre&gt;

(dans cette instruction, &lt;code&gt;self&lt;/code&gt; est bien entendu la référence de l'instance courante).

De la même manière, la méthode constructeur de la classe &lt;code&gt;Ion()&lt;/code&gt; fait appel à la méthode constructeur de sa classe parente, dans :

&lt;pre&gt;
Atome.__init__(self, nat)
&lt;/pre&gt;

[[Image:Apprendre à programmer avec Python 36.png|center|500px|Schéma résumant le fonctionnement d'une classe]]


== Exercices ==
{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Définissez une classe Domino() qui permette d'instancier des objets simulant les pièces d'un jeu de dominos. Le constructeur de cette classe initialisera les valeurs des points présents sur les deux faces A et B du domino (valeurs par défaut = 0).
Deux autres méthodes seront définies :
* une méthode &lt;code&gt;affiche_points()&lt;/code&gt; qui affiche les points présents sur les deux faces ;
* une méthode &lt;code&gt;valeur()&lt;/code&gt; qui renvoie la somme des points présents sur les deux faces.

Exemples d'utilisation de cette classe :

&lt;pre&gt;
&gt;&gt;&gt; d1 = Domino(2,6)
&gt;&gt;&gt; d2 = Domino(4,3)
&gt;&gt;&gt; d1.affiche_points()
face A : 2  face B : 6
&gt;&gt;&gt; d2.affiche_points()
face A : 4  face B : 3
&gt;&gt;&gt; print &quot;total des points :&quot;, d1.valeur() + d2.valeur()
total des points : 15
&gt;&gt;&gt; liste_dominos = []
&gt;&gt;&gt; for i in range(7):
    liste_dominos.append(Domino(6, i))

&gt;&gt;&gt; liste_dominos[1].affiche_points()
face A: 6  face B: 1

etc., etc.
&lt;/pre&gt;
&lt;/li&gt;

&lt;li&gt;Définissez une classe &lt;code&gt;CompteBancaire()&lt;/code&gt;, qui permette d'instancier des objets tels que &lt;code&gt;compte1&lt;/code&gt;, &lt;code&gt;compte2&lt;/code&gt;, etc.  Le constructeur de cette classe initialisera deux attributs d'instance &quot;nom&quot; et &quot;solde&quot;, avec les valeurs par défaut &lt;code&gt;'Dupont'&lt;/code&gt; et &lt;code&gt;1000&lt;/code&gt;.

Trois autres méthodes seront définies :
* &lt;code&gt;depot(somme)&lt;/code&gt; permettra d'ajouter une certaine somme au solde
* &lt;code&gt;retrait(somme)&lt;/code&gt; permettra de retirer une certaine somme du solde
* &lt;code&gt;affiche()&lt;/code&gt; permettra d'afficher le nom du titulaire et le solde de son compte.

Exemples d'utilisation de cette classe :

&lt;pre&gt;
&gt;&gt;&gt; compte1 = CompteBancaire('Duchmol', 800)
&gt;&gt;&gt; compte1.depot(350)
&gt;&gt;&gt; compte1.retrait(200)
&gt;&gt;&gt; compte1.affiche()
Le solde du compte bancaire de Duchmol est de 950 euros.
&gt;&gt;&gt; compte2 = CompteBancaire()
&gt;&gt;&gt; compte2.depot(25)
&gt;&gt;&gt; compte2.affiche()
Le solde du compte bancaire de Dupont est de 1025 euros.
&lt;/pre&gt;&lt;/li&gt;

&lt;li&gt;Définissez une classe &lt;code&gt;Voiture()&lt;/code&gt; qui permette d'instancier des objets reproduisant le comportement de voitures automobiles. Le constructeur de cette classe initialisera les attributs d'instance suivants, avec les valeurs par défaut indiquées :

&lt;code&gt;marque = 'Ford',  couleur = 'rouge',  pilote = 'personne',  vitesse = 0&lt;/code&gt;.

Lorsque l'on instanciera un nouvel objet &lt;code&gt;Voiture()&lt;/code&gt;, on pourra choisir sa marque et sa couleur, mais pas sa vitesse, ni le nom de son conducteur.

Les méthodes suivantes seront définies :

- &lt;code&gt;choix_conducteur(nom)&lt;/code&gt; permettra de désigner (ou changer) le nom du conducteur

- &lt;code&gt;accelerer(taux, duree)&lt;/code&gt; permettra de faire varier la vitesse de la voiture. La variation de vitesse obtenue sera égale au produit : &lt;code&gt;taux x duree&lt;/code&gt;. Par exemple, si la voiture accélère au taux de 1,3 m/s2  pendant 20 secondes, son gain de vitesse doit être égal à 26 m/s. Des taux négatifs seront acceptés (ce qui permettra de décélérer). La variation de vitesse ne sera pas autorisée si le conducteur est &lt;code&gt;'personne'&lt;/code&gt;.

- &lt;code&gt;affiche_tout()&lt;/code&gt; permettra de faire apparaître les propriétés présentes de la voiture, c'est-à-dire sa marque, sa couleur, le nom de son conducteur, sa vitesse.

Exemples d'utilisation de cette classe :

&lt;pre&gt;
&gt;&gt;&gt; a1 = Voiture('Peugeot', 'bleue')
&gt;&gt;&gt; a2 = Voiture(couleur = 'verte')
&gt;&gt;&gt; a3 = Voiture('Mercedes')
&gt;&gt;&gt; a1.choix_conducteur('Roméo')
&gt;&gt;&gt; a2.choix_conducteur('Juliette')
&gt;&gt;&gt; a2.accelerer(1.8, 12)
&gt;&gt;&gt; a3.accelerer(1.9, 11)
Cette voiture n'a pas de conducteur !
&gt;&gt;&gt; a2.affiche_tout()
Ford verte pilotée par Juliette, vitesse = 21.6 m/s.
&gt;&gt;&gt; a3.affiche_tout()
Mercedes rouge pilotée par personne, vitesse = 0 m/s.
&lt;/pre&gt;&lt;/li&gt;

&lt;li&gt;Définissez une classe &lt;code&gt;Satellite()&lt;/code&gt; qui permette d'instancier des objets simulant des satellites artificiels lancés dans l'espace, autour de la terre. Le constructeur de cette classe initialisera les attributs d'instance suivants, avec les valeurs par défaut indiquées :

&lt;code&gt;masse = 100,  vitesse = 0&lt;/code&gt;.

Lorsque l'on instanciera un nouvel objet &lt;code&gt;Satellite()&lt;/code&gt;, on pourra choisir son nom, sa masse et sa vitesse.

Les méthodes suivantes seront définies :

- &lt;code&gt;impulsion(force, duree)&lt;/code&gt; permettra de faire varier la vitesse du satellite. Pour savoir comment, rappelez-vous votre cours de physique : la variation de vitesse &lt;math&gt;\Delta v&lt;/math&gt; subie par un objet de masse ''m'' soumis à l'action d'une force ''F'' pendant un temps ''t'' vaut &lt;math&gt;\Delta v = \frac{F \times \Delta t}{m}&lt;/math&gt;. Par exemple : un satellite de 300 kg qui subit une force de 600 Newtons pendant 10 secondes voit sa vitesse augmenter (ou diminuer) de 20 m/s.

- &lt;code&gt;affiche_vitesse()&lt;/code&gt; affichera le nom du satellite et sa vitesse courante.

- &lt;code&gt;energie()&lt;/code&gt; renverra au programme appelant la valeur de l'énergie cinétique du satellite.

Rappel : l'énergie cinétique &lt;math&gt;E_c&lt;/math&gt; se calcule à l'aide de la formule &lt;math&gt;E_c = \frac{1}{2} m v^2&lt;/math&gt;

Exemples d'utilisation de cette classe :

&lt;pre&gt;
&gt;&gt;&gt; s1 = Satellite('Zoé', masse =250, vitesse =10)
&gt;&gt;&gt; s1.impulsion(500, 15)
&gt;&gt;&gt; s1.affiche_vitesse()
vitesse du satellite Zoé = 40 m/s.
&gt;&gt;&gt; print s1.energie()
200000
&gt;&gt;&gt; s1.impulsion(500, 15)
&gt;&gt;&gt; s1.affiche_vitesse()
vitesse du satellite Zoé = 70 m/s.
&gt;&gt;&gt; print s1.energie()
612500
&lt;/pre&gt;&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
class Domino:
    def __init__(self, pa, pb):
        self.pa, self.pb = pa, pb
         
    def affiche_points(self):
        print &quot;face A :&quot;, self.pa,
        print &quot;face B :&quot;, self.pb
        
    def valeur(self):
        return self.pa + self.pb

# Programme de test :

d1 = Domino(2,6)
d2 = Domino(4,3)

d1.affiche_points()
d2.affiche_points()

print &quot;total des points :&quot;, d1.valeur() + d2.valeur() 

liste_dominos = []
for i in range(7):
    liste_dominos.append(Domino(6, i))

vt =0
for i in range(7):
    liste_dominos[i].affiche_points()
    vt = vt + liste_dominos[i].valeur()
    
print &quot;valeur totale des points&quot;, vt
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
class Voiture:
    def __init__(self, marque = 'Ford', couleur = 'rouge'):
        self.couleur = couleur
        self.marque = marque
        self.pilote = 'personne'
        self.vitesse = 0
        
    def accelerer(self, taux, duree):
        if self.pilote =='personne':
            print &quot;Cette voiture n'a pas de conducteur !&quot;
        else:    
            self.vitesse = self.vitesse + taux * duree
        
    def choix_conducteur(self, nom):
        self.pilote = nom    
        
    def affiche_tout(self):
            print &quot;%s %s pilotée par %s, vitesse = %s m/s&quot; % \
            (self.marque, self.couleur, self.pilote, self.vitesse)     
    
a1 = Voiture('Peugeot', 'bleue')
a2 = Voiture(couleur = 'verte')
a3 = Voiture('Mercedes')
a1.choix_conducteur('Roméo')
a2.choix_conducteur('Juliette')
a2.accelerer(1.8, 12)
a3.accelerer(1.9, 11)
a2.affiche_tout()
a3.affiche_tout()
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
class Satellite:
    def __init__(self, nom, masse =100, vitesse =0):
        self.nom, self.masse, self.vitesse = nom, masse, vitesse
         
    def impulsion(self, force, duree):
        self.vitesse = self.vitesse + force * duree / self.masse
        
    def energie(self):
        return self.masse * self.vitesse**2 / 2    
                
    def affiche_vitesse(self):
        print &quot;Vitesse du satellite %s = %s m/s&quot; \
                          % (self.nom, self.vitesse)

# Programme de test :

s1 = Satellite('Zoé', masse =250, vitesse =10)

s1.impulsion(500, 15)
s1.affiche_vitesse()
print s1.energie()
s1.impulsion(500, 15)
s1.affiche_vitesse()
print s1.energie()
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Définissez une classe &lt;code&gt;Cercle()&lt;/code&gt;. Les objets construits à partir de cette classe seront des cercles de tailles variées. En plus de la méthode constructeur (qui utilisera donc un paramètre &lt;code&gt;rayon&lt;/code&gt;), vous définirez une méthode &lt;code&gt;surface()&lt;/code&gt;, qui devra renvoyer la surface du cercle.

Définissez ensuite une classe &lt;code&gt;Cylindre()&lt;/code&gt; dérivée de la précédente. Le constructeur de cette nouvelle classe comportera les deux paramètres rayon et hauteur. Vous y ajouterez une méthode &lt;code&gt;volume()&lt;/code&gt; qui devra renvoyer le volume du cylindre.

''(Rappel : Volume d'un cylindre = surface de section x hauteur).''

Exemple d'utilisation de cette classe :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; cyl = Cylindre(5, 7)
&gt;&gt;&gt; print cyl.surface()
78.54
&gt;&gt;&gt; print cyl.volume()
549.78
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Complétez l'exercice précédent en lui ajoutant encore une classe Cone(), qui devra dériver cette fois de la classe Cylindre(), et dont le constructeur comportera lui aussi les deux paramètres rayon et hauteur. Cette nouvelle classe possédera sa propre méthode volume(), laquelle devra renvoyer le volume du cône. 

''(Rappel : Volume d'un cône = volume du cylindre correspondant divisé par 3).''

Exemple d'utilisation de cette classe :

&lt;pre&gt;
&gt;&gt;&gt; co = Cone(5,7)
&gt;&gt;&gt; print co.volume()
&lt;/pre&gt;

183.26&lt;/li&gt;

&lt;li&gt;Définissez une classe &lt;code&gt;JeuDeCartes()&lt;/code&gt; permettant d'instancier des objets « jeu de cartes » dont le comportement soit similaire à celui d'un vrai jeu de cartes. La classe devra comporter au moins les trois méthodes suivantes :

- méthode constructeur : création et remplissage d'une liste de 52 éléments, qui sont eux-mêmes des tuples de 2 éléments contenant les caractéristiques de chacune des 52 cartes.
Pour chacune d'elles, il faut en effet mémoriser séparément un nombre entier indiquant la valeur (2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, les 4 dernières valeurs étant celles des valet, dame, roi et as), et un autre nombre entier indiquant la couleur de la carte (c'est-à-dire 0,1,2,3 pour  Cœur, Carreau, Trèfle &amp; Pique).

Dans une telle liste, l'élément (11,2) désigne donc le valet de Trèfle, et la liste terminée doit être du type : &lt;code&gt;[(2, 0), (3,0), (3,0), (4,0),   ...  ...  (12,3), (13,3), (14,3)]&lt;/code&gt;

- méthode &lt;code&gt;nom_carte()&lt;/code&gt; : cette méthode renvoie sous la forme d'une chaîne l'identité d'une carte quelconque, dont on lui a fourni le tuple descripteur en argument.
Par exemple, l'instruction :

&lt;code&gt;print jeu.nom_carte((14, 3))&lt;/code&gt;  doit provoquer l'affichage de : &lt;code&gt;As de pique&lt;/code&gt;

- méthode &lt;code&gt;battre()&lt;/code&gt; : comme chacun sait, battre les cartes consiste à les mélanger.
Cette méthode sert donc à mélanger les éléments de la liste contenant les cartes, quel qu'en soit le nombre.

- méthode &lt;code&gt;tirer()&lt;/code&gt; : lorsque cette méthode est invoquée, une carte est retirée du jeu. Le tuple contenant sa valeur et sa couleur est renvoyé au programme appelant. On retire toujours la première carte de la liste. Si cette méthode est invoquée alors qu'il ne reste plus aucune carte dans la liste, il faut alors renvoyer l'objet spécial &lt;code&gt;None&lt;/code&gt; au programme appelant.

Exemple d'utilisation de la classe &lt;code&gt;JeuDeCartes()&lt;/code&gt; :


&lt;syntaxhighlight lang=python&gt;
jeu = JeuDeCartes()            # instanciation d'un objet
jeu.battre()                   # mélange des cartes
for n in range(53):            # tirage des 52 cartes : 
   c = jeu.tirer() 
   if c == None:               # il ne reste plus aucune carte
      print 'Terminé !'        # dans la liste
   else:
      print jeu.nom_carte(c)   # valeur et couleur de la carte
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Complément de l'exercice précédent : Définir deux joueurs A et B. Instancier deux jeux de cartes (un pour chaque joueur) et les mélanger. Ensuite, à l'aide d'une boucle, tirer 52 fois une carte de chacun des deux jeux et comparer leurs valeurs. Si c'est la première des 2 qui a la valeur la plus élevée, on ajoute un point au joueur A. Si la situation contraire se présente, on ajoute un point au joueur B. Si les deux valeurs sont égales, on passe au tirage suivant. Au terme de la boucle,  comparer les comptes de A et B pour déterminer le gagnant.&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;Voir ci-dessous.&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
#(classes de cylindres et de cônes) :
# Classes dérivées - polymorphisme

class Cercle:
    def __init__(self, rayon):
        self.rayon = rayon

    def surface(self):
        return 3.1416 * self.rayon**2
        
class Cylindre(Cercle):
    def __init__(self, rayon, hauteur):
        Cercle.__init__(self, rayon)
        self.hauteur = hauteur
        
    def volume(self):
        return self.surface()*self.hauteur
        
        # la méthode surface() est héritée de la classe parente
        
class Cone(Cylindre):
    def __init__(self, rayon, hauteur):
        Cylindre.__init__(self, rayon, hauteur)
                
    def volume(self):
        return Cylindre.volume(self)/3
        
        # cette nouvelle méthode volume() remplace celle que
        # l'on a héritée de la classe parente (exemple de polymorphisme)
                            
cyl = Cylindre(5, 7)
print cyl.surface()
print cyl.volume()

co = Cone(5,7)
print co.surface()
print co.volume()
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
# Tirage de cartes

from random import randrange

class JeuDeCartes:
    &quot;&quot;&quot;Jeu de cartes&quot;&quot;&quot;
    # attributs de classe (communs à toutes les instances) :
    couleur = ('Pique', 'Trèfle', 'Carreau', 'Cœur')
    valeur = (0, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'valet', 'dame', 'roi', 'as')

    def __init__(self):
        &quot;Construction de la liste des 52 cartes&quot;
        self.carte =[]          
        for coul in range(4):
            for val in range(13):
                self.carte.append((val +2, coul))   # la valeur commence à 2

    def nom_carte(self, c):
        &quot;Renvoi du nom de la carte c, en clair&quot;
        return &quot;%s de %s&quot; % (self.valeur[c[0]], self.couleur[c[1]])
        
    def battre(self):
        &quot;Mélange des cartes&quot;
        t = len(self.carte)             # nombre de cartes restantes
        # pour mélanger, on procède à un nombre d'échanges équivalent :
        for i in range(t):
            # tirage au hasard de 2 emplacements dans la liste :         
            h1, h2 = randrange(t), randrange(t)     
            # échange des cartes situées à ces emplacements :
            self.carte[h1], self.carte[h2] = self.carte[h2], self.carte[h1]
        
    def tirer(self):
        &quot;Tirage de la première carte de la pile&quot;
        t = len(self.carte)             # vérifier qu'il reste des cartes 
        if t &gt;0:                        
            carte = self.carte[0]       # choisir la première carte du jeu
            del(self.carte[0])          # la retirer du jeu
            return carte                # en renvoyer copie au prog. appelant
        else:
            return None                 # facultatif


### Programme test :

if __name__ == '__main__':
    jeu = JeuDeCartes()                 # instanciation d'un objet
    jeu.battre()                        # mélange des cartes
    for n in range(53):                 # tirage des 52 cartes : 
        c = jeu.tirer()  		 
        if c == None:                   # il ne reste aucune carte
            print 'Terminé !'           # dans la liste
        else:
            print jeu.nom_carte(c)      # valeur et couleur de la carte
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=python&gt;
#(On supposera que l'exercice précédent a été sauvegardé sous le nom cartes.py)
# Bataille de de cartes

from cartes import JeuDeCartes

jeuA = JeuDeCartes()        # instanciation du premier jeu      
jeuB = JeuDeCartes()        # instanciation du second jeu      
jeuA.battre()               # mélange de chacun
jeuB.battre()
pA, pB = 0, 0               # compteurs de points des joueurs A et B

# tirer 52 fois une carte de chaque jeu :
for n in range(52):         
    cA, cB = jeuA.tirer(), jeuB.tirer()
    vA, vB = cA[0], cB[0]   # valeurs de ces cartes
    if vA &gt; vB:
        pA += 1
    elif vB &gt; vA:
        pB += 1             # (rien ne se passe si vA = vB)
    # affichage des points successifs et des cartes tirées :
    print &quot;%s * %s ==&gt; %s * %s&quot; % (jeuA.nom_carte(cA), jeuB.nom_carte(cB), pA, pB) 

print &quot;le joueur A obtient %s points, le joueur B en obtient %s.&quot; % (pA, pB)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}


{{Exercices}}
Créer vous-même un nouveau module de classes, en encodant les lignes d'instruction ci-dessous dans un fichier que vous nommerez &lt;code&gt;formes.py&lt;/code&gt; :
&lt;syntaxhighlight lang=python&gt;
class Rectangle:
    &quot;Classe de rectangles&quot;
    def __init__(self, longueur = 30, largeur = 15):
        self.L = longueur
        self.l = largeur
        self.nom =&quot;rectangle&quot;

    def perimetre(self):
        return &quot;(%s + %s) * 2 = %s&quot; % (self.L, self.l, 
                                            (self.L + self.l)*2)
    def surface(self):
        return &quot;%s * %s = %s&quot; % (self.L, self.l, self.L*self.l)

    def mesures(self):
        print &quot;Un %s de %s sur %s&quot; % (self.nom, self.L, self.l)
        print &quot;a une surface de %s&quot; % (self.surface(),)
        print &quot;et un périmètre de %s\n&quot; % (self.perimetre(),)

class Carre(Rectangle):
    &quot;Classe de carrés&quot;
    def __init__(self, cote =10):
        Rectangle.__init__(self, cote, cote)
        self.nom =&quot;carré&quot;

if __name__ == &quot;__main__&quot;:
    r1 = Rectangle(15, 30)
    r1.mesures()    
    c1 = Carre(13)
    c1.mesures()
&lt;/syntaxhighlight&gt;
    
Une fois ce module enregistré, vous pouvez l'utiliser de deux manières : soit vous en lancez l'exécution comme celle d'un programme ordinaire, soit vous l'importez dans un script quelconque ou depuis la ligne de commande, pour en utiliser les classes :

&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; import formes
&gt;&gt;&gt; f1 = formes.Rectangle(27, 12)
&gt;&gt;&gt; f1.mesures()
Un rectangle de 27 sur 12
a une surface de 27 * 12 = 324
et un périmètre de (27 + 12) * 2 = 78

&gt;&gt;&gt; f2 = formes.Carre(13)
&gt;&gt;&gt; f2.mesures()
Un carré de 13 sur 13
a une surface de 13 * 13 = 169
et un périmètre de (13 + 13) * 2 = 52
&lt;/syntaxhighlight&gt;

On voit dans ce script que la classe &lt;code&gt;Carre()&lt;/code&gt; est construite par dérivation à partir de la classe &lt;code&gt;Rectangle()&lt;/code&gt; dont elle hérite toutes les caractéristiques. En d'autres termes, la classe &lt;code&gt;Carre()&lt;/code&gt; est une classe  fille de la classe &lt;code&gt;Rectangle()&lt;/code&gt;.

Vous pouvez remarquer encore une fois que le constructeur de la classe &lt;code&gt;Carre()&lt;/code&gt; fait appel au constructeur de sa classe parente ( &lt;code&gt;Rectangle.__init__()&lt;/code&gt; ), en lui transmettant la référence de l'instance (c'est-à-dire self) comme premier argument.

Quant à l'instruction : 

&lt;pre&gt;
if __name__ == &quot;__main__&quot;:
&lt;/pre&gt;

placée à la fin du module, elle sert à déterminer si le module est « lancé » en tant que programme (auquel cas les instructions qui suivent doivent être exécutées), ou au contraire utilisé comme une bibliothèque de classes importée ailleurs. Dans ce cas cette partie du code est sans effet.

{{solution}}

{{fin}}

== Références ==
{{références}}</text>
      <sha1>jev522dxgm2n6aiukea7kbe4xkl31gn</sha1>
    </revision>
  </page>
  <page>
    <title>Grammaire néerlandaise/le nom/le diminutif</title>
    <ns>0</ns>
    <id>18027</id>
    <revision>
      <id>684309</id>
      <parentid>570696</parentid>
      <timestamp>2022-08-27T18:45:59Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5370" xml:space="preserve">Le français, comme beaucoup d'autres langues, utilise de temps en temps une forme diminutive d'un mot, par exemple :

:maison - maisonette

Dans la plupart des langues, le diminutif joue un rôle assez limité. Le néerlandais par contre a développé tout un système de diminutifs. On peut même dire que le suffixe diminutif est un des plus importants parmi le peu de suffixes vraiment productifs de la langue. Souvent le diminutif est aussi courant ou même plus courant que le nom lui-même. Il y a même des mots qui n'existent que sous forme de diminutif ou sous forme de diminutifs qui ont été ''lexicalisés'', c'est-à-dire qu'ils fonctionnent comme un mot nouveau qui signifient autre chose que le nom dont ils ont été dérivés.

== Formation ==

Le suffixe de base est ''-je'' dans la langue standardisée. Il y a des variations régionales : souvent ''-je'' est prononcé comme ''-ie'' et en Flandre, on entend souvent ''-ke'': man - manneke, comme par exemple dans ''Manneke Pis''.

Le diminutif est toujours neutre et son pluriel se forme en -s.

{|class=&quot;wikitable&quot;
|{{knop|dak}} het dak ||{{knop|dakje}} het dakje||toit||petit toit / accent circonflexe
|-
|{{knop|jas}} de jas ||{{knop|jasje}} het jasje||manteau||veston
|}

Souvent en prononciation ''-je'' cause la palatellisation de la consonne finale du nom. Ainsi ''sj'' dans ''ja'''''sje''' se prononce un peu comme ''si'' en français ''sien'' (plutôt que ''ch''ien, car le son du 'ch' français est rare en néerlandais). 

Les nasales et liquides finales sont fortifiés avec un plosif :

Après ''-n,-l,-r'' on trouve ''-'''t'''je'' :

{|class=&quot;wikitable&quot;
|-
|{{knop|laan}} ''de laan'' ||{{knop|laantje}} ''het laantje''||avenue||(petit)
|-
|{{knop|veer}} ''de veer'' ||{{knop|veertje}} ''het veertje''||plume||petite plume, plumule
|-
|{{knop|paal}} ''de paal'' ||{{knop|paaltje}} ''het paaltje''||poteau|| borne
|}
Un ''-ng'' final devient ''-n'''k'''je'' si l'accent du mot se situe sur la syllabe pénultième:

: ''de koning'' - ''het koninkje'' 

Autrement ''-ng'' devient ''-ngetje''

: ''het ding'' - ''het dingetje''
: ''de verandering'' - ''het veranderingetje''

Après ''-m'' on trouve parfois ''-'''p'''je'' :

: ''het rijm'' - ''het rijmpje''
: ''de bloem'' - ''het bloempje''

Mais dans le dernier cas on trouve aussi ''-''''et'''je'' :

:''de bloem'' -'' het bloemetje''

Cette insertion d'une autre syllabe est plus commune :

: ''de koningin'' - ''het koninginnetje''

Si la voyelle change de courte en longue dans le pluriel, le diminutif peut suivre le pluriel :

: ''het pad'' - ''de paden'' - ''het p'''aa'''dje'' (le chemin)
: ''de pad'' - ''de padden'' - ''het padje'' (le crapeau)

Souvent il y a plusieurs formes :

: ''de weg'' - ''het wegje, het weggetje, het weegje''

Il y a des irrégularités dans les mots avec un pluriel en ''-eren'' :

: ''het kind'' - pluriel : ''de kinderen''. Diminutif : ''het kindje'' - ''de kindertjes''
: ''het rad'' - pluriel : ''de raderen'' . Diminutif : het radje, raadje, radertje - de radertjes
: ''het lam'' - pluriel ''de lammeren''. Diminutif : ''het lammetje - de lammetjes''

== Usage ==

La base du diminutif est de contraster le petit et le grand, par exemple :

: ''de vaas'' - ''het vaasje'' 

Un vase que l'on prend facilement dans une seule main est un ''vaasje''. Un vase plus grand ''vaas''. Un ticket est toujours ''kaartje'', tout comme une carte de visite : visitekaar''tje''. On n'a pas vraiment besoin de deux mains dans un tel cas ! 
Ainsi c'est le diminutif qui est rencontré le plus souvent pour des objets de taille limitée.

Souvent le diminutif impart la connotation d'une certaine affection.

: ''mijn liefje!'' - mon/ma chéri(e)

Une autre connotation est celle de la familiarité ou d'un usage inofficiel.

: ''een brief'' - ''een briefje'' 

Une lettre officielle est toujours ''brief''. Un bout de papier quelconque peut être ''briefje''. Dans ces cas, le diminutif gagne un aspect péjoratif :

: ''een boterbriefje'' - litt. une petite lettre de beurre. Se dit d'un contrat de mariage (en geste).

== Lexicalisation ==

: ''rijm'' - la rime
::''mannelijk rijm'' - la rime masculine
: ''rijmpje'' - un petite poème (d'amateur)
:: ''kinderrijmpje'' - une rime d'enfant

Dans ce cas, on voit que le diminutif a évolué dans une direction particulière. Il y a des mots où la différence est plus grande. Un exemple qui existe aussi en français :

: ''de viool'' - le violon
: ''het viooltje'' - la violette

:''het ijs'' - ''het ijsje'' 
: la glace (l'eau congelée) - la glace (crème glacée)

En hiver, s'il gèle, on trouve ''ijs'' sur un lac. Par contre, on mange ''een ijsje'' pour dessert. Et on peut même en manger une grande : ''een groot ijsje''.

Dans le dernier cas, la lexicalisation a fait perdre la connotation « de petite taille ».

Le suffixe diminutif n'est pas limité aux nom substantifs. On l'ajoute aux adjectifs avec un -s en formant des adverbes:

: ''zacht'' - ''zachtjes'' (- doucement)

Il y même des phrases prépositionelles qui ont formé des noms nouveaux :

: ''onder ons'' - parmi nous
: ''het onderonsje'' - le rendez-vous intime

Dans le dernier cas, le nom ''*onderons'' n'existe pas. 

Il y plusieurs exemples de ''diminutiva tanta'', voir: [[:nl:wikt:categorie:Zelfstandig verkleinwoord]]

[[Catégorie:Grammaire néerlandaise (livre)|le nom]]</text>
      <sha1>a4di7mi2uu2khspqjwgsaikdy15v4ri</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Assembleur/x86/Les flags</title>
    <ns>0</ns>
    <id>18203</id>
    <revision>
      <id>684319</id>
      <parentid>671117</parentid>
      <timestamp>2022-08-28T09:23:58Z</timestamp>
      <contributor>
        <ip>129.104.237.1</ip>
      </contributor>
      <comment>Typo : &quot;et&quot; au lieu de &quot;est&quot;</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6897" xml:space="preserve">{{Programmation assembleur x86}}

Les flags (ou indicateurs en français) sont des bits stockés dans un registre spécifique nommé &lt;code&gt;F&lt;/code&gt;, &lt;code&gt;FLAGS&lt;/code&gt; ou &lt;code&gt;EFLAGS&lt;/code&gt;. Chaque bit correspond à différents tests sur les derniers opérandes utilisés durant la dernière opération effectuée (opération arithmétique, comparaison, ...).

L'opération de comparaison de deux valeurs effectue une soustraction entre les deux opérandes sans stocker le résultat. Le positionnement des indicateurs donne le résultat de la comparaison.

Ces différents indicateurs ont tous un nom court de deux lettres dont la deuxième est F signifiant '''F'''lag.

== Le registre F ==
Le registre EFLAGS (extended flags) contient un mot de 32 bits qui sont les suivants :
 bit   31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16
 flag   0   0   0   0   0   0   0   0   0   0  ID  VIP VIF AC  VM  RF

 bit   15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0
 flag   0  NT   IOPL   OF  DF  IF  TF  SF  ZF   0  AF   0  PF   1  CF

Le registre FLAGS correspond aux 16 bits de poids faibles du registre EFLAGS.

Le registre RFLAGS contient un double mot de 64 bits dont les 32 bits de poids faibles contiennent EFLAGS.

== Zero Flag (ZF) ==
Cet indicateur est positionné à 1 si les deux opérandes utilisés sont égaux, sinon positionné  à 0.
Son nom vient de la différence nulle entre les deux opérandes.

== Overflow Flag (OF) ==
Cet indicateur est positionné à 1 si le dernier résultat a débordé de la taille du registre,sinon à 0 .

Cet indicateur est utilisé par [[../Les branchements#Saut conditionnel|les sauts conditionnels]] :
* L'instruction &lt;code&gt;JO&lt;/code&gt; permet de poursuivre l'exécution à l'adresse indiquée si l'incateur OF est à 1 (Jump if Overflow),
* L'instruction &lt;code&gt;JNO&lt;/code&gt; permet de poursuivre l'exécution à l'adresse indiquée si l'incateur OF est à 0 (Jump if No Overflow),

Quand cet indicateur est à 1, l'instruction &lt;code&gt;INTO&lt;/code&gt; (INTerrupt if Overflow) appelle [[../Les interruptions#Liste des interruptions|l'interruption 4 (débordement)]]. S'il est à 0, l'instruction &lt;code&gt;INTO&lt;/code&gt; ne fait rien.

== Carry Flag (CF) ==
Cet indicateur est positionné à 1 si la dernière opération a générée une retenue (mode non signé),sinon à 0 .

Trois instructions permettent de modifier cet indicateur :
* L'instruction &lt;code&gt;CLC&lt;/code&gt; (CLear Carry) positionne l'indicateur CF à 0 (pas de retenue),
* L'instruction &lt;code&gt;STC&lt;/code&gt; (SeT Carry) positionne l'indicateur CF à 1 (retenue),
* L'instruction &lt;code&gt;CMC&lt;/code&gt; (CompleMent Carry) change l'indicateur CF à 0 s'il valait 1, ou à 1 s'il valait 0.

Cet indicateur est utilisé par [[../Les branchements#Saut conditionnel|les sauts conditionnels]] (JC, JNC, JB, JNB, ...).

Il est également pris en compte par les instructions arithmétiques suivantes :
* L'instruction &lt;code&gt;ADC&lt;/code&gt; (ADd with Carry) ajoute la valeur de l'indicateur à la somme des opérandes,
* L'instruction &lt;code&gt;SBB&lt;/code&gt; (SuBstract with Borrow) soustrait la valeur de l'indicateur à la différence entre les opérandes.

== Auxiliary carry Flag (AF) ==
Cet indicateur est positionné à 1 si la dernière opération a généré une retenue du bit numéro 3 vers le bit numéro 4, à 0 sinon.

== Sign Flag (SF) ==
Cet indicateur est positionné à 1 si la dernière opération a généré un résultat négatif, à 0 s'il est positif ou nul.

== Parity Flag (PF) ==
Cet indicateur est positionné à 1 si dans les 8 bits de poids faible du résultat de la dernière opération, le nombre de bits à 1 est pair, à 0 si ce nombre est impair.

Cet indicateur est utile pour la détermination du bit de parité pour la transmission octet par octet.

== Interrupt Flag (IF) ==
Cet indicateur est positionné à 1 si [[../Les interruptions|les interruptions]] sont autorisées, à 0 sinon.

Deux instructions permettent de modifier cet indicateur :
* L'instruction &lt;code&gt;CLI&lt;/code&gt; (CLear Interrupt) positionne l'indicateur IF à 0 (interruptions ignorées),
* L'instruction &lt;code&gt;STI&lt;/code&gt; (SeT Interrupt) positionne l'indicateur IF à 1 (interruptions autorisées).

== Direction Flag (DF) ==
Cet indicateur est positionné à 1 si le transfert de données se fait en décrémentant les offsets, à 0 sinon (incrémentation des offsets).
Cet indicateur modifie le comportement des [[../Copie entre registres et mémoire#Transfert de séquence|instructions de chaînes d'octets (STOS*, LODS*, CMPS*, SCAS*, MOVS*)]].

Deux instructions permettent de modifier cet indicateur :
* L'instruction &lt;code&gt;CLD&lt;/code&gt; (CLear Direction) positionne l'indicateur DF à 0 (UP : incrémentation des offsets),
* L'instruction &lt;code&gt;STD&lt;/code&gt; (SeT Direction) positionne l'indicateur DF à 1 (DOWN : décrémentation des offsets).

== Trap Flag (TF) ==
Cet indicateur est positionné à 1 pour exécuter les instructions en mode pas à pas.

Quand cet indicateur est activé, avant chaque instruction, le processeur appelle [[../Les interruptions#Liste des interruptions|l'interruption 1]] (INT 1).
Cette interruption est utilisée par les débogueurs quand le mode pas à pas est activé :
# Le débogueur défini le vecteur pour l'interruption 1 pointant vers une routine exécutée après chaque instruction ;
# Puis l'indicateur ''Trap Flag'' (TF) est mis à 1 (en utilisant la pile et l'instruction POPF).

La routine de débogueur est alors exécutée après chaque instruction ce qui lui permet de :
* tracer la valeur des registres après chaque instruction,
* décrémenter un compteur d'instructions et interrompre l'exécution quand le compteur atteint zéro,
* détecter quand une condition complexe arrive et interrompre l'exécution.

Quand la condition d'interruption de l'exécution est d'atteindre une adresse particulière, une méthode plus efficace est de placer un point d'arrêt.

== Accès au registre des indicateurs ==
Les indicateurs sont utilisés par les instructions de saut conditionnels.

Il est possible d'accéder au registre des indicateurs de deux manières :
* En utilisant [[../La pile|la pile]] :
** Le registre des indicateurs est copié sur [[../La pile|la pile]] (empilé) par l'instruction &lt;code&gt;PUSHF&lt;/code&gt;,
** Il est lu depuis [[../La pile|la pile]] (dépilé) par l'instruction &lt;code&gt;POPF&lt;/code&gt;.
* En passant par [[../Registres#Les registres de travail|le registre AH]] :
** L'instruction &lt;code&gt;LAHF&lt;/code&gt; charge les 8 bits de poids faible du registre des indicateurs vers le registre AH,
** L'instruction &lt;code&gt;SAHF&lt;/code&gt; copie le contenu du registre AH dans les 8 bits de poids faible du registre des indicateurs.

L'instruction non documentée &lt;code&gt;SETALC&lt;/code&gt; initialise le registre AL selon la valeur de l'indicateur de retenue (CF) en y stockant 0xFF si CF vaut 1, ou 0x00 sinon.

[[Catégorie:Programmation Assembleur x86 (livre)]]</text>
      <sha1>n4h9enaapqtgueukgqgyjues32g3puh</sha1>
    </revision>
  </page>
  <page>
    <title>Livre de cuisine/Tarte aux mirabelles</title>
    <ns>0</ns>
    <id>18903</id>
    <revision>
      <id>684297</id>
      <parentid>647624</parentid>
      <timestamp>2022-08-27T18:31:54Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="608" xml:space="preserve">{{Livre de cuisine}}
La '''tarte au mirabelles''' est un dessert.

== Ingrédients ==
* 1 [[Livre de cuisine/Pâte brisée|pâte brisée]],
* 300 g de {{i|mirabelle|mirabelles}},
* 50 g de {{i|sucre}}.

== Préparation ==
# Étaler la pâte au fond d'un plat à tartes ;
# Garnir de mirabelles en rangs bien serrés ;
# Saupoudrer de sucre en poudre ;
# Enfourner la tarte à [[Thermostat de cuisson|180°C]], cuire 25 min.

== Variantes ==
* La ''migaine'' : mélanger un œuf, de la crème et du sucre, verser la préparation sur la tarte garnie de mirabelles.

[[Catégorie:Desserts|Tarte aux mirabelles]]</text>
      <sha1>humdtavctmdpydb05e0wiodntuztyse</sha1>
    </revision>
  </page>
  <page>
    <title>Le système d'exploitation GNU-Linux/Les répertoires importants</title>
    <ns>0</ns>
    <id>20435</id>
    <revision>
      <id>684293</id>
      <parentid>675375</parentid>
      <timestamp>2022-08-27T18:29:07Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5972" xml:space="preserve">&lt;noinclude&gt;
{{Linux}}
&lt;/noinclude&gt;

Une des premières difficultés pour les débutants Unix est de se repérer dans l'arborescence. Contrairement à un environnement Windows qui regroupe toutes les ressources nécessaires à un programme dans un même répertoire, les ressources dans un système unix (et dans une moindre mesure MacOS) sont réparties dans une hiérarchie générale. Ainsi si le code exécutable d'un programme se trouve dans le répertoire &lt;code&gt;/bin&lt;/code&gt;, ses libraries se trouveront dans le répertoire &lt;code&gt;/lib&lt;/code&gt; et ses fichiers de configuration dans le répertoire &lt;code&gt;/etc&lt;/code&gt;.

La hiérarchie des systèmes unix est normalisée, la spécification étant accessible sur http://www.pathname.com/fhs/

Voici une liste des répertoires à connaître.

== Les programmes exécutables ==
* /bin : les commandes indispensables
* /usr/bin : les autres commandes
* /usr/local/bin : les commandes installées à la main

== Les programmes exécutables du super-utilisateur root ==
* /sbin : les programmes indispensables d'administration
* /usr/sbin : les autres programmes d'administration
* /usr/local/sbin : les programmes d'administration installées à la main

== Les fichiers de configuration ==
* /etc

En particulier, /etc contient les fichiers:
 /etc/passwd               liste des comptes utilisateurs et leurs répertoires associés.
 /etc/shadow               liste des comptes utilisateurs et leurs mots de passe chiffrés.
 /etc/X11/xorg.conf        fichier de configuration du serveur graphique.

== Le(s) noyau(x) Linux ==
* /boot

== Les répertoires de travail des utilisateurs ==
* /home

Chaque utilisateur du système aura un répertoire dans /home portant son nom.

Par exemple le bureau de l'utilisateur &quot;wiki&quot; se trouve dans :
 /home/wiki/Bureau

NB : si le bureau montre des icônes qui ne figure pas dans &quot;/home/wiki/Bureau&quot;, on peut les retirer par exemple sur Gnome avec :
 gsettings set org.gnome.shell.extensions.ding show-home false
 gsettings set org.gnome.shell.extensions.ding show-trash false

== Le répertoire de travail du super-utilisateur root ==
* /root

== Les librairies partagées ==
* /lib : les librairies indispensables
* /usr/lib : les autres librairies
* /usr/local/lib : les librairies des programmes installés à la main

== Les points de montage ==
* /mnt : Répertoire dans lequel on pourra créer des points de montage pour des systèmes de fichiers temporaires, destiné à un usage d'appoint. Les composants vitaux du système ne doivent pas dépendre de ce répertoire.
* /media : Répertoire dans lequel des points de montage seront créés automatiquement pour accéder aux supports de stockage amovibles (cdrom, clé usb...)

== Les périphériques ==
* /dev

En particulier, on trouve les fichiers :
 /dev/hda  ou hdb ou sda etc. qui correspondent aux disques dur. Les disques durs IDE sont notés hd et les SATA ou SCSI sont notés sd
 /dev/hda1 ou hda2 etc. qui correspondent aux partitions des disques. hda1 est la 1ere partition du premier disque IDE (hda).

 /dev/eth0 qui correspond à la première carte réseau. Pour plus d'une carte réseau, on verra apparaître d'autres fichiers /dev/eth.

 /dev/audio qui correspond au périphérique son.

== Les autres programmes et leurs fichiers annexes ==
* /usr

Ce répertoire est en lecture-seule et est destiné à être partagé.
Les programmes installés par le système d'exploitation se trouvent dans /usr/bin.
Les programmes installés manuellement par les utilisateurs se trouvent dans /usr/local.

« usr » veut dire ''{{lang|en|Unix System Ressources}}'' et non pas ''user''. Les fichiers relatifs aux utilisateurs du système se trouvent dans le répertoire « /home ».

== Le système de fichier virtuel ==
Donne les infos de la machine
* /proc
===== sur le processeur =====
Ex:/proc/cpuinfo 
===== sur la mémoire =====
Ex:/proc/meminfo

===== sur les modules =====
Ex:/proc/modules
===== sur les montages du systeme =====
Ex:/proc/mount
===== sur la swaps =====
Ex:/proc/swaps

== Les fichiers temporaires ==
* /tmp
*/var/tmp

== Les données variables ==
* /var

Ce répertoire contient les données variables. En particulier:
 les logs sont stockés dans /var/log
 les mails en attente de livraison sont stockées dans /var/mail
 les travaux d'impression seront dans /var/spool ou /var/mail selon le serveur d'impression utilisé.

* /var/log, ce répertoire contient les journaux (fichiers détaillant les historiques de programmes).
* /var/mail, ce répertoire contient les emails des utilisateurs du système. Un utilisateur du système peut voir ses emails via la commande « mail ».
* /var/spool, ce répertoire contient les données en attente de traitement (par un programme), et sont en générale supprimé après avoir été traité. 
*/var/lib, ce répertoire contient les données des bases de données (Mysql, Postgresql) et les bases de données dpkg (rpm sur RedHat)
*/var/www : les sites Web

== Les programmes et ressources installés à la main ==
* /usr/local

Ce répertoire contient des données mis en place par l'administrateur du système, comme « /usr » mais dans un contexte plus « isolé » car ces ressources sont géré par ce même administrateur système, et contient des sous-répertoire tel que:
 /usr/local
 ├── bin/                   : où se trouvent les programmes.
 │   ├── monprogramme       : exemple de programme nommé « monprogramme ».
 ├── etc/                   : où se trouvent les fichiers de configurations des programmes, comme « /etc ».
 │   ├── monprogramme.conf  : exemple de configuration de « monprogramme ».
 ├── lib/                   : où se trouvent les bibliothèques logiciel.
 ├── lib64/                 : où se trouvent les bibliothèques logiciel, compilé pour les processeurs à architecture 64 bits.
 ├── sbin/                  : où se trouvent les programmes utilisable par &quot;root&quot;.</text>
      <sha1>qs2qyik8pk8oh9jmq5nkmtt0vmrf3om</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/L/Lucien Lorelle</title>
    <ns>0</ns>
    <id>21004</id>
    <revision>
      <id>684271</id>
      <parentid>618997</parentid>
      <timestamp>2022-08-27T18:12:50Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10603" xml:space="preserve">{{Ph s Personnalités}}


== Biographie ==

'''Lucien Lorelle''' (Paris, 1894 - Megève, 26 février 1968) est un des principaux photographes français du début du XXe siècle et l'un des fondateurs du [[w:Groupe des XV|Groupe des XV]].

Lucien Lorelle fut pilote de chasse lors de la Première Guerre mondiale. À l'issue du conflit, il a voyagé dans toute l'Europe, notamment en Roumanie où il résida un temps. Il voulait se consacrer à la peinture mais il dut y renoncer face à l'opposition familiale. Entré comme secrétaire général au studio des frères Manuel, des portraitistes réputés, il y découvrit la photographie

Artiste doué dans bien d'autres domaines comme la poésie, le dessin, la peinture, l'écriture et la musique, il marqua de son influence la photographie française pendant quatre décennies. Ses domaines de prédilection étaient le '''portrait''', la '''mode''' et la '''publicité'''.

* En 1927, il crée le « Studio Lorelle » avec son beau-frère [[Marcel Amson]]. Le photographe tchèque [[w:Jaroslav Rössler|Jaroslav Rössler]] (1902-1990) et la photographe allemande [[w:Erna Wagner-Hehmke|Erna Wagner-Hehmke]] (1905 - 1992) y ont étudié la photographie et réalisé une partie de leur œuvre.

* L'année 1935 voit la cession du studio à son beau-frère et l'installation du « Studio Lucien Lorelle » rue Lincoln.

* En mars 1946, il participe à la fondation du « [[Groupe des XV]] ».

* En 1952, il crée '''Central Color''', le premier grand laboratoire photographique professionnel couleurs français. Ce laboratoire sera repris et dirigé par sa fille, Françoise Gallois, jusqu’en 2003, puis par un de ses arrière-petit-fils qui a su l'adapter aux nouvelles techniques numériques.

* Le 28 février 1968, décès subit du photographe à Megève.

== Principaux domaines d'activité ==

=== Le portrait ===
Comme portraitiste, il eut l'occasion de photographier toutes les célébrités de son époque comme [[W:Annabella|Annabella]], [[w:Marie Glory|Marie Glory]], [[w:Martine Carol|Martine Carol]], [[w:Dominique Wilms|Dominique Wilms]], [[w:Micheline Presle|Micheline Presle]], [[w:Danièle Darrieux|Danièle Darrieux]], [[w:Albert Préjean|Albert Préjean]], [[w:Jean Cocteau|Jean Cocteau]], [[w:Gérard Philipe|Gérard Philipe]], [[w:Madeleine Robinson|Madeleine Robinson]], [[w:Madeleine Sologne|Madeleine Sologne]], [[w:Serge Reggiani|Serge Reggiani]], [[w:Jean Marais|Jean Marais]], [[w:Michel Simon|Michel Simon]], [[w:Jean Gabin|Jean Gabin]], [[w:Janine Grenet|Janine Grenet]], [[w:Michel Galabru|Michel Galabru]] et bien d’autres. Ses portraits étaient fort différents des œuvres américaines alors en vogue et il parlait lui-même, à leur propos, de « théâtres de lumières ». 

=== La mode ===
Dans le domaine de la mode, il n'avait pas son pareil pour donner vie aux coiffures et aux vêtements, s'éloignant très vite du caractère par trop guindé des photographies du [[Photographie/Personnalités/M/Adolf Gayne de Meyer|baron de Meyer]] ou d'[[Photographie/Personnalités/S/Edward Steichen|Edward Steichen]] et devenant en quelque sorte un précurseur si l'on en juge par la liberté de mouvement laissée ou imposée aux modèles dans la photographie de mode contemporaine.

=== La publicité ===

[[Image:Ingres, The source.jpg|thumb|70px|La source (D. Ingres)]]

Il réalise des campagnes publicitaires pour les [[w:Groupe Galeries Lafayette|Galeries Lafayette]] (avec [[w:Cassandre (graphiste)|Cassandre]]) et d'innombrables marques très connues comme [[w:L'Oréal|L'Oréal]], [[w:Pernod|Pernod]], [[w:Perrier|Perrier]], [[w:Teppaz|Teppaz]], [[w:Philips|Philips]], [[w:Winston|Winston]], [[w:Cinzano|Cinzano]], [[w:Chanel|Chanel]], [[w:Shell|Shell]], etc. Dans ses images publicitaires, il fit souvent le choix d'utiliser plusieurs personnages pour en quelque sorte raconter une histoire, avec une mise en scène aussi soignée que pour une pièce de théâtre. L'un de ses plus célèbres photographies publicitaires restera la jolie jeune fille dévêtue qu'il photographia pour l'[[w:Ambre solaire|Ambre solaire]] dont [[Photographie/Personnalités/M/Daniel Masclet|Daniel Masclet]] disait qu'elle lui rappelait ''La source'' de [[w:Dominique Ingres|Dominique Ingres]].

===Autres œuvres ===

Il est aussi l'auteur de nombreuses photographies surréalistes et d'hommages littéraires mêlant textes, dessins et photographies. Il s'efforçait de faire « éclater » les règles de la photographie en utilisant de multiples techniques telles que la solarisation, l'inversion, le découpage, le brûlage, etc. Comme le dit [[Jean-Claude Gautrand]] : « S'il revendique ses influences surréalistes, Lorelle est cependant toujours resté, par esprit d'indépendance, à l'extérieur de ce groupe. S'il excelle à tenter de dévoiler l'envers du miroir, il le fait à sa manière, en toute liberté, et il n'hésite pas à mélanger les genres. Pour lui, la photo n'est jamais fermée sur elle-même, elle n'est jamais achevée et toujours prête à révéler un autre sens pour peu qu'on la déstructure. »

== L'homme ==

Lucien Lorelle, doué comme on l'a vu dans des domaines divers, était aussi un orateur brillant qui savait faire partager sa passion pour son art et un pédagogue à qui l'on doit de nombreux ouvrages et articles qui furent traduits en plusieurs langues dont l'allemand, l'anglais et l'espagnol.

Nul mieux que son ami Daniel Masclet ne pouvait le dépeindre : « Lorelle avait l'étoffe d'un maître, d'un homme qui ne se contente jamais des réponses, mais qui pose sans cesse de nouvelles questions ».

« Lorelle était un homme de goûts simples : selon la célèbre définition de Winston Churchill, &quot;il était aisément satisfait avec le meilleur&quot; ... C'est pourquoi ses techniques, si elles furent toujours raffinées, ne furent jamais compliquées : une chambre à pied quelconque, un reflex souvent, du papier au bromure brillant, il ne lui fallait rien d'autre pour créer. Il appartenait à cette race d'hommes - d'artistes - très rares, qui peuvent dire ''Je n'ai besoin de rien''. Dessinateur habile, peintre surréaliste, fortement teinté de littératures, il avait pourtant le bon sens de ne pas mélanger les arts, de rester peintre en peinture, photographe en photographie. Écrivain disert et prolifique, il a écrit plusieurs livres didactiques et publié deux beaux albums, entièrement consacrés au ''nu à travers le monde''. »

« Un dernier détail, qui n'a peut-être pas grand rapport avec la valeur même de l'artiste en tant qu'artiste, mais qui est pour moi peut-être le plus important : Lorelle était un homme très bon. »

== Expositions ==

* '''Photographes Humanistes''', du 31 octobre 2006 au 28 janvier 2007 à la [http://www.bnf.fr/ BNF], site Richelieu, Galerie de photographie, Paris.

* '''Rétrospective Lucien Lorelle''', en partenariat avec Central Color ; du 5 octobre 2007 au 26 janvier 2008 au 23/25 rue du Gué à Rueil-Malmaison dans les Hauts-de-Seine, présentation de 50 photographies et de documents couvrant ses travaux des années 1920 à 1960.

* '''Lucien Lorelle, le charme de l'avant-garde''', du 12 au 20 mai 2012, expositions à Arles et aux Baux-de-Provence.

== Publications et contributions ==

* ''Paris et la beauté féminine'' (avec des illustrations de Lucien Lorelle) .- Paris, Société d’Éditions Modernes Parisiennes, 1945.
      
* LANGELAAN, Donald et LORELLE, Lucien .- ''La photographie publicitaire'' .- Paris, Paul Montel, 1949.

* LORELLE, Lucien .- ''Le portrait photographique'' .- Paris, Paul Montel, 1950.

* LORELLE, Lucien .- ''Le livre de la couleur directe'' .- Paris, Paul Montel, 1951.

* LORELLE, Lucien .- ''Le livre de mon 6 x 9 et des formats moyens.'' - Paris, Paul Montel, 1951. 3e édition, 152 p. Traduit en espagnol en 1953 : ''Tamaño 6x9 y los formatos medianos'', Ediciones omega, Barcelone.

* LORELLE, Lucien .- ''Traité pratique de la prise de vue en couleurs'' .- Paris, Paul Montel, 1954, 166 p.

* LORELLE, Lucien .- ''Le guide du photographe amateur'' .- Paris, Paul Montel, 1955, 152 p.

* LORELLE, Lucien .- ''Photos et propos sur le nu'', avec 97 photographies et 27 dessins de l'auteur .- Paris, Paul Montel, 1956.

* [[Photographie/Personnalités/R/Jean Roubier|ROUBIER, Jean]] .- ''La photographie et le cinéma d’amateur'', avec une série de photographies de Lucien Lorelle .- Paris, Larousse, 1956, 442 P. + 32 p. de photographies.

* LORELLE, Lucien .- ''The colour book of photography'' .- Londres, The Focal Press, 1956 (3e édition, 212 p.)

* LORELLE, Lucien .- ''Manual do Fotógrafo'' .- Lisbonne, Edição Difel, 1956.

* LORELLE, Lucien .- ''Le livre de la couleur en photo et cinéma'' .- Paris, Paul Montel, 1957, 166 p.

* LORELLE, Lucien .- ''Photos couleurs pour tous'' .- Paris, Paul Montel, 1959.

* LORELLE, Lucien .- ''Photos et propos sur le nu'' .- Paris, Paul Montel, 1960, 80 p.

* ''Chemins de fer français'' (illustrations de Lucien Lorelle, Josse Noe et Vincent Robert) .- Paris, SNCF, 1961.

* LORELLE, Lucien .- ''L'art du portrait photographique, noir et blanc et couleurs'' .- Paris, Paul Montel, 1962, 142 p.

* LORELLE, Lucien .- ''Esthétique du nu dans le monde'' .- Paris, Paul Montel, 1964, 200 p. ''Weiblicher Akt'' (traduction par Waldemar Sonntag), Bonn, Verlag der Europäischen Bücherei H. M. Hieronimi, 1964.

* MARIEL, Pierre .- ''Die Schönen von Paris Quartier Latin St Germain des Prés'', illustrations de Lucien Lorelle .- Bonn, Verlag der Europäischen Bücherei H. M. Hieronimi, 1965.

* LORELLE, Lucien .- ''Akt Auslese'' (traduction par Waldemar Sonntag) .- Bonn, Verlag der Europäischen Bücherei H. M. Hieronimi, vers 1965.

* LORELLE, Lucien .- ''Lumière et couleur sur le nu'' .- Paris, Paul Montel, 196-, 120 p. ''Akt in Farbe und Licht'', traduction en allemand, Bonn, Verlag der Europäischen Bücherei H. M. Hieronimi.

* ''PARIS 1950 photographié par le Groupe des XV'', illustré en partie par des photographies de Lucien Lorelle .- Paris, Bibliothèque historique de la Ville de Paris, 1982.

== Bibliographie ==

* [[Jean-Claude Gautrand|GAUTRAND, Jean-Claude]] .- Lucien Lorelle, le charme de l'avant-garde. In : ''Réponses Photo'', n° 42, mai 2012, pp. 82-89.

* [[Daniel Masclet|MASCLET, Daniel]] .- ''Lucien Lorelle, photographe''. In : ''Photo-Ciné-Revue'', avril 1968, pp. 192-193.

== Liens externes ==
* [http://www.lucienlorelle.com/ Site Lucien Lorelle]


{{Ph Personnalités}}

{{DEFAULTSORT:Lorelle, Lucien}}

[[Catégorie:Personnalités de la photographie]]</text>
      <sha1>nig81qajb7iqodb7qf6uhpu8urae9mz</sha1>
    </revision>
  </page>
  <page>
    <title>Le système d'exploitation GNU-Linux/Le partage de fichiers Samba</title>
    <ns>0</ns>
    <id>21822</id>
    <revision>
      <id>684295</id>
      <parentid>675368</parentid>
      <timestamp>2022-08-27T18:30:21Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="31521" xml:space="preserve">&lt;noinclude&gt;
{{Linux}}
&lt;/noinclude&gt;

== Introduction ==

Samba est l'implémentation du protocole SMB (Server Message Block) sous Unix / Linux. Il sert à partager des fichiers et des imprimantes avec les réseaux Microsoft.

Site officiel : [http://www.samba.org www.samba.org]

Samba lance deux services : '''smbd''' et '''nmbd'''.

Le protocole SMB est tout sauf performant : il pollue le réseau par l'utilisation intensive du broadcast.

Samba utilise les ports '''137''' (netbios name service, nbname, en UDP), '''138''' (netbios datagram service nbdatagram, en UDP), '''139''' (netbios session service, nbsession, en TCP), et '''445''' (&quot;direct-hosted&quot; tcp, en tcp et udp). 

La méthode de connexion traditionnelle smb utilise les ports 137, 138 et 139 tandis que la nouvelle méthode (CIFS, sur Windows XP) n'utilise que le port 445.

== Installation ==

Pour installer Samba, on tape la commande suivante :

  # apt-get install samba smbclient smbfs winbind

== Configuration ==

Le fichier de configuration de Samba est '''/etc/samba/smb.conf'''.

Le programme '''testparm '''analyse le fichier smb.conf et signale les erreurs éventuelles.

Après avoir modifié la configuration, il faut relancer le service :

  # /etc/init.d/samba restart


Le fichier '''/etc/samba/smb.conf''' se divise en différentes sections :

* La section '''[global]''' : configuration globale de samba

* La section '''[homes]''' :  cette section particulière permet de remonter une ressource qui correspond au répertoire de travail (home directory) de l'utilisateur qui s'est authentifié.

On peut ensuite créer différentes sections, une par partage voulu.

Samba peut fonctionner de différentes manières. Voici quelques cas de figures courants.


== Le partage par ressource sur un réseau Workgroup ==

Voici un fichier '''/etc/samba/smb.conf''' permettant de partager une ressource (répertoire ou imprimante) sur un réseau Workgroup :

  # PARTAGE PAR RESSOURCES (share)
  
  # Il y a 2 cas possibles :
  #
  # CAS n°1 : on partage une ressource totalement anonyme
  # CAS n°2 : on partage une ressource avec un mot de passe associé à la ressource
   
  # Section GLOBAL
  # Configuration globale de Samba
  [global]
        # Nom du groupe de travail
        workgroup = WORKGROUP
        
        # Nom Netbios de la machine (identification réseau)
        netbios name = PC230
        
        # Chaine de commentaire associé au serveur (voisinage réseau)
        server string = %h Serveur (Samba %v)
        
        # Utilisateurs interdits
        invalid users = root
        
        # Enregistre un fichier de log par machine cliente du réseau MS
        log file = /var/log/samba/log.%m
        
        # Taille maximale des logs : 1 Mo
        max log size = 1000
        
        # On n'utilise pas Syslog pour enregistrer les logs
        syslog = 0
        
        # On fait un partage par ressources
        security = share
        
        # On utilise les mots de passe encryptés
        # (attention, W95 et W98a fonctionnent avec les mdp en clair)
        encrypt passwords = true
        
        # Accélère les transferts réseaux
        socket options = TCP_NODELAY
        
        # Empeche nmbd de chercher à résoudre le nom netbios via le DNS
        dns proxy = no
        
        # Nom du compte invité qui va permettre de créer une
        # ressource partagée par mot de passe (celui du compte invite)
        guest account = invite
        
        # Emplacement du fichier contenant les logins et mdp samba
        smb passwd file = /etc/samba/smbpasswd
        
        # Pour récupérer les imprimantes définies dans CUPS
        printing = cups  
        
        
  # Section HOMES
  # Cette section est inutile ici car on utilise le mode share
  
  
  # Section PRINTERS
  # Cette section permet de partager les imprimantes définies sur le serveur
  [printers]
        # Le commentaire associé à l'imprimante
        comment = Les imprimantes
        
        # Affiche les imprimantes dans la liste des partages du serveur
        browseable = yes
        
        # Dans le cas d'une imprimante, c'est l'emplacement 
        # des fichiers temporaires
        path = /tmp
  
        # Spécifie qu'il s'agit d'une imprimante et non un répertoire
        printable = yes
        
        # Partage l'imprimante de manière anonyme
        public = yes
        
        # Logique
        writable = no
        
        # Empeche d'autres utilisateurs de supprimer mes impressions
        create mode = 0700
  
  
  # Sections REPERTOIRES PARTAGES
  
  # CAS n°1: un CDROM partagé anonymement
  [cdrom]
        # Le commentaire associé au CDROM
        comment = Le CDROM
        
        # Point de montage du CDROM
        # synonyme de directory =
        path = /cdrom
        
        # Empeche le bloquage d'un fichier par un utilisateur
        locking = no
         
        # Logique
        writable = no
        
        # Partage le CDROM de manière anonyme
        public = yes
  
  
  # CAS n°2 : un répertoire partagé mais protégé par mot de passe
  [partage]
        # Le commentaire associé au répertoire
        comment = Un répertoire partagé mais protégé par mot de passe
        
        # Emplacement du répertoire partagé
        path = /home/partage
        
        # Support en lecture / écriture
        # synonyme de read only = no
        writable = yes
        
        # Partage anonyme désactivé (cas par défaut)
        # synonyme de guest ok = no
        public = no
        
        # Voir explication ci-dessous
        valid users = invite
        
        # Masque de création des fichiers et répertoires
        create mask = 0644
        directory mask = 0755
         
Dans le cas du mode share, pour pouvoir positionner un mot de passe sur une ressource, il faut créer un compte UNIX 'invite' :

  # adduser --shell /bin/false --disabled-login invite

On crée ensuite une entrée dans le fichier /etc/samba/smbpasswd :

  # smbpasswd -a invite

Le mot de passe saisi correspondra à celui du répertoire partagé.

'''NB''' : dans les versions récentes de Samba, il faut utiliser la commande '''pdbedit''' à la place de '''smbpasswd''' :

  # pdbedit -a invite

Il faut ensuite créer le répertoire partagé et donner l'arborescence partagée à l'utilisateur invite du groupe invite :

  # mkdir /home/partage
  # chown '''nobody'''.invite /home/partage

NB : il faut que l'utilisateur '''nobody''' ait le droit d'écriture sur le répertoire partagé.

Petit rappel : il est toujours utile de faire un '''testparm''' pour vérifier la cohérence du fichier de configuration, et ne pas oublier de relancer le service pour que les modifications soient prises en compte.

On peut tester la configuration avec la commande '''smbclient''' :

  # smbclient -L PC230
  Password:
  Domain=[WORKGROUP] OS=[Unix] Server=[Samba 3.0.24]
  
        Sharename       Type      Comment
        ---------       ----      -------
        cdrom           Disk      Le CDROM
        partage         Disk      Un répertoire partagé mais protégé par mot de passe
        IPC$            IPC       IPC Service (pc230 Serveur (Samba 3.0.24))
        HP_LaserJet_1200_LPT_parport0_HPLIP Printer   HP LaserJet 1200
  
  Domain=[WORKGROUP] OS=[Unix] Server=[Samba 3.0.24]
  
        Server               Comment
        ---------            -------
        PC230                pc230 Serveur (Samba 3.0.24)

        Workgroup            Master
        ---------            -------
        ...                  ...
        

La commande '''smbclient''' demande un mot de passe, on tape '''entrée'''.

== Le partage par utilisateur sur un réseau Workgroup ==

Voici un fichier '''/etc/samba/smb.conf''' permettant de partager une ressource (répertoire ou imprimante) avec une authentification '''Utilisateur / Mot de passe''' sur un réseau Workgroup :

  # PARTAGE PAR UTILISATEUR (user) - Groupe de travail
  
  # Il y a 2 cas possibles :
  #
  # CAS n°1 : on partage une ressource totalement anonyme
  # CAS n°2 : cas normal du mode user, on fait une authentification 
  #           par login et mot de passe
  
  
  # Section GLOBAL
  # Configuration globale de Samba
  [global]
        # Nom du groupe de travail
        workgroup = WORKGROUP
        
        # Nom Netbios de la machine (identification réseau)
        netbios name = PC230
        
        # Chaîne de commentaire associé au serveur (voisinage réseau)
        server string = %h Serveur (Samba %v)
        
        # Utilisateurs interdits
        invalid users = root
        
        # Enregistre un fichier de log par machine cliente du réseau MS
        log file = /var/log/samba/log.%m
        
        # Taille maximale des logs : 1 Mo
        max log size = 1000
        
        # On n'utilise pas Syslog pour enregistrer les logs
        syslog = 0
        
        # On fait un partage par utilisateur
        security = user
        
        # On utilise les mots de passe encryptés
        # (attention, W95 et W98a fonctionnent avec les mdp en clair)
        encrypt passwords = true
        
        # Accélère les transferts réseaux
        socket options = TCP_NODELAY
        
        # Empêche nmbd de chercher à résoudre le nom netbios via le DNS
        dns proxy = no
        
        # Nom du compte invité qui va permettre de créer une
        # ressource partagée par mot de passe (celui du compte invite)
        # POUR LE CAS n°1
        guest account = invite
        
        # Emplacement du fichier contenant les logins et mdp samba
        # concerne le CAS n°1 et n°2
        smb passwd file = /etc/samba/smbpasswd
        
        
  # Section HOMES
  # Cette section particulière permet de remonter une ressource
  # qui correspond au répertoire de travail (home directory)
  # de l'utilisateur qui s'est authentifié
  [homes]
        # Correspond au home directory de l'utilisateur authentifié
        # %U sera remplacé par le nom d'utilisateur (login)
        comment = Le répertoire personnel de %U
        
        # Si on active cette option, on dispose d'une ressource 'homes'
        # redondante avec la ressource 'login'
        browseable = no
        
        # Il faut que l'utilisateur soit authentifié pour accéder
        # à la ressource (son home directory sur le serveur)
        public = no
        
        # Autorise l'écriture dans le répertoire personnel
        writable = yes
        
        # Droits d'accès des fichiers et répertoires créés
        create mask = 0644
        directory mask = 0755
        
        
  # Section PRINTERS
  # Cette section permet de partager les imprimantes définies sur le serveur
  [printers]
        # Le commentaire associé à l'imprimante
        comment = Les imprimantes
        
        # Affiche les imprimantes dans la liste des partages du serveur
        browseable = yes
        
        # Dans le cas d'une imprimante, c'est l'emplacement 
        # des fichiers temporaires
        path = /tmp
        
        # Spécifie qu'il s'agit d'une imprimante et non un répertoire
        printable = yes
        
        # Partage l'imprimante de manière anonyme
        public = yes
        
        # Logique
        writable = no
        
        # Empêche d'autres utilisateurs de supprimer mes impressions
        create mode = 0700
        
        
  # Sections REPERTOIRES PARTAGES
  
  # CAS n° 1 : une ressource anonyme sans mot de passe
  # Un CDROM
  [cdrom]
        # Le commentaire associé au CDROM
        comment = Le CDROM
        
        # Point de montage du CDROM
        # synonyme de directory =
        path = /cdrom
        
        # Empêche le bloquage d'un fichier par un utilisateur
        locking = no
        
        # Logique
        writable = no
        
        # Partage le CDROM de manière anonyme
        public = yes
        
        
  # CAS n°2 : un répertoire partagé qu'à certains utilisateurs
  [prive]
        # Le commentaire associé au répertoire
        comment = Un répertoire partagé qu'a certains utilisateurs (CAS n°2) 
        
        # Emplacement du répertoire partagé
        path = /home/prive
        
        # Support en lecture / écriture
        # synonyme de read only = no
        writable = yes
        
        # Partage anonyme désactivé (cas par défaut)
        # synonyme de guest ok = no
        public = no
        
        # Voir explication ci-dessous
        # le @prive désigne le groupe Unix 'prive'
        valid users = @prive
        
        # Masque de création des fichiers et répertoires
        create mask = 0644
        directory mask = 0755
        

Dans le cas du mode user, pour ne partager une ressource partagée qu'à certains utilisateurs, il faut tout d'abord créer un compte UNIX pour chacun d'eux :

  # adduser --shell /bin/false --disabled-login paul
  # adduser --shell /bin/false --disabled-login pierre

On crée ensuite une entrée dans le fichier /etc/samba/smbpasswd :

  # smbpasswd -a paul
  # smbpasswd -a pierre

'''NB''' : dans les versions récentes de Samba, il faut utiliser la commande '''pdbedit''' à la place de '''smbpasswd''' :

  # pdbedit -a paul
  # pdbedit -a pierre

Coté Linux, les utilisateurs doivent avoir le droit d'écriture sur le répertoire partagé. La meilleure méthode consiste à créer un groupe Unix contenant les utilisateurs autorisés, et d'attribuer le répertoire partagé au groupe en question :

  # addgroup prive
  # adduser paul prive
  # adduser pierre prive
  # mkdir /home/prive
  # chgrp prive /home/prive
  # chmod 770 /home/prive

Avantage : pour partager cette ressource à de nouveaux utilisateurs, il suffit de leur créer le compte Unix, une entrée dans smbpasswd et de les ajouter au groupe prive (il n'est plus nécessaire de modifier le fichier smb.conf).

  # chmod g+s /home/prive

Permet de définir le propriétaire des fichiers créés avec l'option +s. Ici les propriétaires seront les membres du groupe '''prive''' au lieu de l'utilisateur.

== Connexion à un Active Directory Windows 2012 ==

Serveur AD : SERV2012 (192.168.10.254)

Domaine : DOMWIN.LAN

=== Configuration de /etc/resolv.conf ===
Il faut indiquer dans le fichier /etc/resolv.conf d'utiliser le serveur AD en tant que serveur DNS :
 # cat /etc/resolv.conf
 nameserver 192.168.10.254

=== Configuration de Kerberos ===
On installe Kerberos pour l'authentification sur AD :
 # apt-get install krb5-{admin-server,user}
On configure Kerberos avec notre domaine AD (DOMWIN.LAN) :
 # cat /etc/krb5.conf
 
 [logging]
 Default = FILE:/var/log/krb5.log
 
 [libdefaults]
 ticket_lifetime = 24000
 clock-skew = 300
 default_realm = domwin.lan
 &lt;nowiki&gt;#&lt;/nowiki&gt; dns_lookup_realm = false
 &lt;nowiki&gt;#&lt;/nowiki&gt; dns_lookup_kdc = true
 
 [realms]
 domwin.lan = {
 kdc = 192.168.10.254:88
 admin_server = 192.168.10.254:464
 default_domain = domwin.lan
 }
 
 [domain_realm]
 .domwin.lan = domwin.lan
 domwin.lan = domwin.lan

=== Configuration de Samba ===
 ...
 [global]
     workgroup = DOMWIN
     netbios name = ALEX
     wins support = no
     security = ads
     realm = DOMWIN.LAN
 ...

=== Connexion au domaine AD ===
On obtient un ticket Kerberos :
 # kinit Administrateur@DOMWIN.LAN
 &lt;nowiki&gt;#&lt;/nowiki&gt; klist

On récupére le SID du serveur AD (nom netbios de AD : SERV2012) :
 # net rpc getsid -S SERV2012

On rejoint le domaine AD :
 # net ads join -U Administrateur -S SERV2012

On vérifie en interrogeant les partages du serveur AD. Pour cela, on utilise un compte définit sur AD :
 # smbclient -L SERV2012 -U etudiant

On essaye d'accéder à un partage définit sur AD :
 &lt;nowiki&gt;# smbclient '\\SERV2012\partage' -U etudiant&lt;/nowiki&gt;

''Fichiers /etc/krb5.conf et /etc/samba/smb.conf : Voir pastebin.com/EDxh7yqH''

== Le partage sur un domaine Microsoft ==

Voici un fichier '''/etc/samba/smb.conf''' permettant de rejoindre un domaine existant afin de partager des ressources :

  # PARTAGE PAR UTILISATEUR (server) - Domaine avec authentification
  # déléguée à un controleur de domaine (PDC : Primary Domain Controller)
  
  # Il y a 2 cas possibles :
  #
  # CAS n°1 : on partage une ressource totalement anonyme
  # CAS n°2 : cas normal du mode user, on fait une authentification 
  #           par login et mot de passe
  
  
  # Section GLOBAL
  # Configuration globale de Samba
  [global]
        # Nom du groupe de travail
        workgroup = DOMAINE
         
        # Nom Netbios de la machine (identification réseau)
        netbios name = PC230
        
        # Chaine de commentaire associé au serveur (voisinage réseau)
        server string = %h Serveur (Samba %v)
        
        # Utilisateurs interdits
        invalid users = root
        
        # Enregistre un fichier de log par machine cliente du réseau MS
        log file = /var/log/samba/log.%m
        
        # Taille maximale des logs : 1 Mo
        max log size = 1000
        
        # On n'utilise pas Syslog pour enregistrer les logs
        syslog = 0
        
        # On fait un partage par utilisateur, l'authentification est
        # déléguée au controleur de domaine (PDC)
        security = server
        password server = PDC
        
        # On utilise les mots de passe encryptés
        # (attention, W95 et W98a fonctionnent avec les mdp en clair)
        encrypt passwords = true
        
        # Accélère les transferts réseaux
        socket options = TCP_NODELAY
        
        # Empeche nmbd de chercher à résoudre le nom netbios via le DNS
        dns proxy = no
        
        # Nom du compte invité qui va permettre de créer une
        # ressource partagée par mot de passe (celui du compte invite)
        # POUR LE CAS n°1
        guest account = invite
        
        # Emplacement du fichier contenant les logins et mdp samba
        # concerne le CAS n°1 et n°2
        smb passwd file = /etc/samba/smbpasswd
  
  
  # Section HOMES
  # Cette section particulière permet de remonter une ressource
  # qui correspond au répertoire de travail (home directory)
  # de l'utilisateur qui s'est authentifié
  [homes]
        # Correspond au home directory de l'utilisateur authentifié
        # %U sera remplacé par le nom d'utilisateur (login)
        comment = Le répertoire personnel de %U
  
        # Si on active cette option, on dispose d'une ressource 'homes'
        # redondante avec la ressource 'login'
        browseable = no
  
        # Il faut que l'utilisateur soit authentifié pour accéder
        # à la ressource (son home directory sur le serveur)
        public = no
  
        # Autorise l'écriture dans le répertoire personnel
        writable = yes
  
        # Droits d'accés des fichiers et répertoires créés
        create mask = 0644
        directory mask = 0755
        
  
  # Section PRINTERS
  # Cette section permet de partager les imprimantes définies sur le serveur
  [printers]
        # Le commentaire associé à l'imprimante
        comment = Les imprimantes
  
        # Affiche les imprimantes dans la liste des partages du serveur
        browseable = yes
  
        # Dans le cas d'une imprimante, c'est l'emplacement 
        # des fichiers temporaires
        path = /tmp
  
        # Spécifie qu'il s'agit d'une imprimante et non un répertoire
        printable = yes
  
        # Partage l'imprimante de manière anonyme
        public = yes
  
        # Logique
        writable = no
  
        # Empeche d'autres utilisateurs de supprimer mes impressions
        create mode = 0700
  
  
  # Sections REPERTOIRES PARTAGES
  
  # CAS n° 1 : une ressource anonyme sans mot de passe
  # Un CDROM
  [cdrom]
        # Le commentaire associé au CDROM
        comment = Le CDROM
  
        # Point de montage du CDROM
        # synonyme de directory =
        path = /cdrom
  
        # Empeche le bloquage d'un fichier par un utilisateur
        locking = no
        
        # Logique
        writable = no
  
        # Partage le CDROM de manière anonyme
        public = yes
  
  
  # CAS n°2 : un répertoire partagé qu'à certains utilisateurs
  [prive]
        # Le commentaire associé au répertoire
        comment = Un répertoire partagé qu'à certains utilisateurs (CAS n°2) 
  
        # Emplacement du répertoire partagé
        path = /home/prive
  
        # Support en lecture / écriture
        # synonyme de read only = no
        writable = yes
  
        # Partage anonyme désactivé (cas par défaut)
        # synonyme de guest ok = no
        public = no
        
        # Voir explication ci-dessous
        # le @prive désigne le groupe Unix 'prive'
        valid users = @prive
  
        # Masque de création des fichiers et répertoires
        create mask = 0644
        directory mask = 0755
  
Remarque : Pour que le serveur Linux puisse rejoindre le domaine existant, il faut se connecter au moins une fois avec le compte '''Administrateur'''  défini sur le contrôleur de domaine, afin que ce dernier crée un compte machine :

  # net join -U Administrateur
  Administrateur's password:
  [2008/02/12 11:58:41, 0] utils/net_ads.c:ads_startup(289)
  ads_connect: Chaîne multi-octets ou étendue de caractères invalide ou incomplète
  ADS join did not work, falling back to RPC...
  '''Joined domain DOMAINE.'''

Dans le cas du mode server, les utilisateurs (login et mot de passe) sont définis sur un serveur existant.

Coté Linux, les utilisateurs doivent avoir le droit d'écriture sur le répertoire partagé. Cependant, les utilisateurs ne sont pas définis sur le serveur Linux mais sur le contrôleur de domaine. La solution consiste à permettre à tout le monde d'écrire dans ce répertoire, Samba se chargeant de n'autoriser que les utilisateurs autorisés sur le contrôleur de domaine.

  # mkdir /home/prive
  # chmod 777 /home/prive

== Samba en contrôleur de domaine Microsoft ==

Voici un fichier '''/etc/samba/smb.conf''' permettant de faire un contrôleur de domaine Microsoft :

  # Controleur de domaine PDC (Primary Domain Controller)
  
  # Section GLOBAL
  # Configuration globale de Samba
  [global]
        # Nom du groupe de travail
        workgroup = DOMAINE
         
        # Nom Netbios de la machine (identification réseau)
        netbios name = PC230
  
        # Chaine de commentaire associé au serveur (voisinage réseau)
        server string = %h Serveur (Samba %v)
  
        # Utilisateurs interdits
        invalid users = root
  
        # Enregistre un fichier de log par machine cliente du réseau MS
        log file = /var/log/samba/log.%m
  
        # Taille maximale des logs : 1 Mo
        max log size = 1000
  
        # On n'utilise pas Syslog pour enregistrer les logs
        syslog = 0
  
        # On est PDC, on fait l'authentification par utilisateur
        security = user
  
        # On utilise les mots de passe encryptés
        # (attention, W95 et W98a fonctionnent avec les mdp en clair)
        encrypt passwords = true
          
        # Accélère les transferts réseaux
        socket options = TCP_NODELAY
  
        # Empeche nmbd de chercher à résoudre le nom netbios via le DNS
        dns proxy = no
  
        # Nom du compte invité qui va permettre de créer une
        # ressource partagée par mot de passe (celui du compte invite)
        guest account = invite
  
        # Emplacement du fichier contenant les logins et mdp samba
        smb passwd file = /etc/samba/smbpasswd
  
        # Permet de devenir le master browser du réseau
        # Le master browser est responsable de l'état du réseau
        # C'est en général le PDC qui effectue cette tache
        local master = yes
  
        # Permet de devenir le DOMAIN master browser du réseau
        domain master = yes
  
        # Cette option permet de déclencher une election sur le réseau 
        # afin de déterminer qui sera le master browser
        # Le fait de déclencher cette election me donne le plus de chance
        # devenir ce master browser
        preferred master = yes
  
        # Si ce chiffre est le plus grand du réseau, je deviens le PDC
        os level = 255
  
        # Permet aux utilisateurs de changer leur mot de passe sur ce serveur
        # depuis leur poste
        update encrypted = yes
  
        # Définit que le daemon nmbd doit agir en tant que serveur WINS
        wins support = yes
  
        # Winbind permet de placer des machines dans un domaine controlé 
        # par un PDC et d'autoriser les utilisateurs a accéder
        # à ces machines en utilisant les informations du PDC
        winbind separator = +
        winbind enum users = no
        winbind enum groups = no
        winbind uid = 10000-20000
        winbind gid = 10000-20000
  
        # désactive le support des ACL (Access Control List)
        # fonctionnalité utilisée par Active Directory
        nt acl support = no
  
        # Logins autorisés à se connecter aux ressources administratives
        # comme C$, ADMIN$ et IPC$
        admin users = admin
  
        # PRIMORDIAL !, sinon ca marche pas :
        # il faut que la ressource [netlogon] existe, meme si on n'utilise
        # pas un script logon
        domain logons = yes
        
        # Nom du fichier netlogon
        logon script = logon.bat  
  
        # Pour autoriser les utilisateurs a changer leurs mots de passe
        passwd program = /usr/bin/passwd %u
        passwd chat = *Enter\snew\sUnix\spassword:* %n\n *Retype\snew\sUnix\spassword:* %n\n
  
  # Section NETLOGON
  # Permet de faire exécuter un script d'initialisation réseau par le poste 
  # client du domaine. Ceci permet par exemple connecter un lecteur réseau (Z:) ou de synchroniser l'heure
  [netlogon]
        # Il n'apparaitra pas dans la liste des ressources partagées
        browsable = no
  
        # Répertoire contenant le netlogon
        path = /etc/samba/netlogon
  
        # Le netlogon n'a pas besoin d'etre public
        public = no
  
        # Pour la sécurité, cette ressource est exportée en read only
        writable = no
  
        # Permet à plusieurs utilisateurs d'utiliser le meme fichier
        # en meme temps
        locking = no
  
  ### Ce serveur effectuant la mission cruciale de PDC, il n'est pas
  ### recommandé de partager des ressources, bien que cela soit possible
  
  [homes]
        path = %H
        browsable = no
        writable = yes
        public = no
  
  [partage]
        path = /home/partage
        public = yes
        browsable = yes
  
  
  [profiles] 
        comment = Partage pour stocker les profils itinérants
        path =  /home/samba/profiles
        writable = yes
        browseable = no 
        create mode = 0644
        directory mode = 0755


On crée ensuite le compte de l'utilisateur '''admin'''. il faudra utiliser ce compte lors de la première connexion d'un ordinateur au domaine.

  # adduser --shell /bin/false --disabled-login admin
  # smbpasswd -a admin

'''NB:''' Sur une Ubuntu, le groupe '''admin''' existe déjà, donc, soit on rajoute l'option '''--ingroup users''', soit on utilise un compte différent pour l'administration (ex: Administrateur).

'''NB2''' : dans les versions récentes de Samba, il faut utiliser la commande '''pdbedit''' à la place de '''smbpasswd''' :

  # pdbedit -a admin

Pour chaque membre du domaine, il faut créer un compte unix correspondant à la machine et rajouter une entrée de type machine dans smbpasswd.

Attention : ce login doit porter le nom netbios de la machine et se terminer par un dollar (d'ou le --force-badname) :

  # adduser --shell /bin/false --disabled-login --force-badname nompc$ 
  # smbpasswd -a -m nompc$       # '''ou''' ''pdbedit -a -m nompc$''

'''NB''' : On peut automatiser la création des comptes machines en rajoutant la ligne suivante dans la section '''[global]''' de smb.conf :

''Sous Debian :''

  '''add machine script = /usr/sbin/adduser --shell /bin/false --disabled-login --force-badname %u'''

''Sous Redhat :''

  '''add machine script = /usr/sbin/useradd -d /var/lib/nobody -g 100 -s /bin/false -M %u'''


Il faut aussi créer le répertoire pouvant accueillir le '''netlogon''' :

  # mkdir /etc/samba/netlogon

On crée également le répertoire stockant les profils itinérants :

  # mkdir -p /home/samba/profiles
  # chmod 777 /home/samba/profiles

Le '''netlogon''' peut servir par exemple à créer automatiquement un volume réseau (ex: '''Z:'''), ou ajuster l'heure de l'ordinateur avec celle du contrôleur de domaine.

On peut optionnellement créer un fichier logon.bat :

  # echo '@echo off' &gt; /etc/samba/netlogon/logon.bat
  # echo 'echo Bienvenue sur le domaine' &gt;&gt; /etc/samba/netlogon/logon.bat
  # echo 'net use T: \\PC230\partage' &gt;&gt; /etc/samba/netlogon/logon.bat
  # echo 'net time \\PC230 /set /yes' &gt;&gt; /etc/samba/netlogon/logon.bat
  # echo 'pause' &gt;&gt; /etc/samba/netlogon/logon.bat

Il faut ensuite relancer samba et '''winbind''' :
  # /etc/init.d/samba restart
  # /etc/init.d/winbind restart

== Utilisation de smbclient ==

smbclient est un client pour les réseaux samba.

Exemple :
  &gt;smbclient -L PC230
  Password:
  Domain=[WORKGROUP] OS=[Unix] Server=[Samba 3.0.24]
  
        Sharename       Type      Comment
        ---------       ----      -------
        cdrom           Disk      Le CDROM
        partage         Disk      Un rÃ©pertoire partagÃ© mais protÃ©gÃ© par mot de passe
        IPC$            IPC       IPC Service (pc230 Serveur (Samba 3.0.24))
        HP_LaserJet_1200_LPT_parport0_HPLIP Printer   HP LaserJet 1200
  
  Domain=[WORKGROUP] OS=[Unix] Server=[Samba 3.0.24]
  
        Server               Comment
        ---------            -------
        BLACKPEARL
        CHRIS-B48CAF99F
        D
        DEBIANTOINE          Debiantoine server
        PC230                pc230 Serveur (Samba 3.0.24)
        PCPROF-LDKBQYFP
        Workgroup            Master
        ---------            -------
        ATELIER              BOOWISS-MOBIL
        CIS                  KALMIYA
        HOUCINE              ORDI-PARIS02
        KOOKYOO.LAN          KOOKYNUX
        LECHAT               CREUFOP12
        NONOLEROBOT          SERVERPARIS01
        PC237'S DOMAIN       PC237
        WORKGROUP            DEBIANTOINE


== Monter un répertoire réseau ==

'''Manuellement :'''

  # mount -t smbfs -o username=invite,password=invite //PC230/partage /mnt
  # ...
  # umount /mnt

'''Automatique à chaque démarrage :'''

Rajouter dans '''/etc/fstab''' :

  # &lt;file system&gt; &lt;mount point&gt; &lt;type&gt; &lt;options&gt; &lt;dump&gt; &lt;pass&gt;
  ...
  //PC230/partage /mnt smbfs username=invite,passwd=invite 0 0

== Utilisation de SWAT : Samba Web Administration Tools ==

SWAT est une page web permettant de configurer samba de façon plus &quot;simple&quot;, mais comme souvent avec les interfaces graphiques, de manière moins pointue.

Pour les amateurs du clickodrôme:
  # apt-get install swat

&lt;Image de SWAT&gt;

Une fois installé, on accède à SWAT avec un navigateur sur l'adresse localhost:901
Swat va lire le fichier smb.conf et le présenter dans une page html. Les onglets permettent de configurer les partages, les imprimantes, de voir les docs etc.
Par défaut, l'accès distant à SWAT est interdit, mais il est activable. Toutefois, il est déconseillé d'utiliser cette option.</text>
      <sha1>1oxhs898y7uupjow9za9w6tbrjv0i45</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/B/Laurent Bouvet</title>
    <ns>0</ns>
    <id>22817</id>
    <revision>
      <id>684274</id>
      <parentid>368993</parentid>
      <timestamp>2022-08-27T18:14:41Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="715" xml:space="preserve">{{Ph s Personnalités}}

'''Laurent Bouvet''' est un photographe français spécialisé dans la photographie de [[ph_nature|nature]] et d'[[ph_sport|activités sportives]]. Son travail est publié dans la presse et l’édition. Il est le fondateur de l’[[ph_agence#Rapsodia|Agence Rapsodia]].

== Expositions ==
* 2005 : Objectif Bastille, Paris.

== Publications ==
* Objectif grands espaces et fortes émotions [photos d'[[sport|escalade et de parachutisme]]] ! In : Photofan, n° 3, 15 janvier 2005, pp. 96-103.

==Média==
* L'œil du photographe - Laurent Bouvet. Première diffusion le 27 novembre 2004 sur [[w:TF1|TF1]] - 

{{DEFAULTSORT:Bouvet, Laurent}}

[[Catégorie:Personnalités de la photographie]]</text>
      <sha1>mxdcnqvpiisjwfv6yqaju9an8lph3zj</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/N/Helmut Newton</title>
    <ns>0</ns>
    <id>23097</id>
    <revision>
      <id>684267</id>
      <parentid>642677</parentid>
      <timestamp>2022-08-27T18:08:30Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8549" xml:space="preserve">{{Ph s Personnalités}}

à venir


== Comment la France a perdu le fonds Newton ==

Citation d'un article de Michel Guerrin paru dans le journal ''Le Monde'' du 20 mars 2004 :

Pendant des années, le photographe a cherché un point de chute en France pour ses archives, en vain. Juste avant sa mort, le 23  janvier, il a tenté de donner à l’État cinquante de ses images, mais les discussions sur leur exposition ont tourné au fiasco. C'est finalement Berlin qui a hérité du cadeau.

L'affaire est navrante. Elle a eu lieu quelques mois avant qu'Helmut Newton, roi de la mode, du portrait et du porno chic, un des photographes les plus célèbres au monde, ne meure, le 23  janvier à Hollywood, à l'âge de 83  ans. Newton, qui a réalisé la majorité de son œuvre pour le Vogue français, a voulu donner une cinquantaine de ses images à la France. Joli cadeau. Surtout quand on sait que certaines de ses icônes atteignent 400 000 dollars pièce. Les négociations ont fini en fiasco.

Pis que cela. Cette affaire, révélée par Pierre Assouline dans Le Monde du 8 février, n'est que la cerise empoisonnée sur le gâteau d'incompréhension qui, depuis vingt ans, brouille les relations entre l’État français et Newton. Ce dernier, dès les années 1980, dit-on au ministère de la culture, a cherché un &quot;point de chute&quot; dans une institution française pour ses archives - négatifs, tirages de collection, contacts, carnets, livres...

De guerre lasse, il est allé voir ailleurs : une Fondation Newton ouvrira ses portes à Berlin, sa ville natale, qu'il avait fui en 1938 parce qu'il était juif. Elle ouvrira le 4 juin dans un « palais » néoclassique offert par la ville. Newton était « tombé amoureux » de Paris, où il a vécu une bonne vingtaine d'années, avant de s'établir à Monaco, en 1981, afin de « s'éloigner de
l'omniprésent percepteur ». Surtout, dans son œuvre, « c'est la Parisienne qu'il photographie, pas la Berlinoise ! », s'exclame José Alvarez, directeur des éditions du Regard et intime de Newton.

Marie-Claude Beaud, qui était directrice du Musée des arts décoratifs en 1997, se souvient : « Newton était prêt à nous donner tout son travail de mode. Je l'ai rencontré à Monaco, puis à Paris. On a échoué. Une donation est difficile quand le photographe veut encore s'occuper de la diffusion de ses images. On a manqué de souplesse ». Elle ajoute : « Helmut a vu d'autres
personnes et partout ça a échoué ».&quot;

Le photographe a contacté le Centre Pompidou notamment, « mais Helmut détestait la façon dont la photographie y était traitée », dit José Alvarez. Ce dernier ajoute : « Helmut a même téléphoné à Bernadette Chirac pour lui demander de l'aider ». Peu avant que Newton signe avec Berlin, au printemps 2003, José Alvarez se voit confier par le photographe une mission de la dernière chance. L'éditeur contacte le ministre de la culture et de la communication, Jean-Jacques Aillagon. Ce dernier écrit à deux reprises au photographe pour dire son intérêt. Jean-Noël Jeanneney, président de la Bibliothèque nationale de France, est aussi contacté dans le but, dit ce dernier, de recevoir « l'ensemble des archives ». Mais, dit José Alvarez, « les choses ont traîné et
Helmut a signé à Berlin ».

Qu'à cela ne tienne, les contacts se poursuivent, cette fois pour une donation. Helmut Newton et sa femme, June, rencontrent à trois reprises des représentants du ministère de la culture - le 2 mai et le 30 septembre à Paris, puis le 30 octobre à Monaco.

'''MANQUE DE RESPECT'''

« Nous avons évoqué une donation d'une cinquantaine de tirages concernant son travail de mode à Paris, de format 50 x 60 cm, pouvant être complétés par des grands formats, qui devaient donner lieu à une exposition durant la période inaugurale du nouveau Jeu de paume », dit Martin Bethenod, délégué aux arts plastiques au ministère de la culture. Il est fan de Newton. Est
présent, le 30 septembre, Régis Durand, directeur du nouveau Jeu de paume, place de la Concorde, que le ministère a décidé de consacrer à la photographie et qui ouvrira le 23 juin.

Survient le clash. June Newton s'en est expliquée auprès de Pepita Dupont, journaliste à Paris Match : « Je n'avais plus de nouvelles. Helmut était trop fier pour appeler. C'est moi qui l'ai fait. À chaque fois, Régis Durand était très difficile à joindre. Finalement, je l'ai eu et il m'a répondu : ''C'est un malentendu, il n'est plus question de rétrospective mais on exposera votre don quand on l'aura reçu dans une petite salle''. J'ai été profondément blessée par ce manque de respect pour mon mari ».

Pour Martin Bethenod, il s'agit d'un « malentendu regrettable. Il n'a jamais été question de grande exposition mais d'exposer la donation. En six mois, nous avons fait plus que d'autres en dix ans ». Régis Durand se dit « consterné par cette affaire. C'est un ratage, on n'a pas su le convaincre. Mais comment aurais-je pu proposer une exposition d'ouverture alors que j'avais déjà mon programme quand je l'ai rencontré ? ». Parole contre parole. Sans doute l’État n'a-t-il pas été d'une totale clarté en évoquant
« une exposition dans la période inaugurale ». Il est d'autant plus dommage de n'avoir pas su accepter ce cadeau que, selon
le marchand zurichois de Newton, Andrea Caratsch, pour obtenir un grand Newton en vente, il faut compter de 100 000 à 500 000 dollars. Or, apprend-on par le ministère de la culture, une seule photographie de Newton figure dans les collections de l’État. Pourtant, des images en tout genre ont été achetées à tour de bras, au nom de l’État, depuis vingt ans.

'''PROJETS D'HOMMAGES'''

Cette affaire révèle la façon dont Helmut Newton et, au-delà, la production d'images liée à la mode sont considérés dans le monde de l'art. « Les musées français et le monde de l'art contemporain me méprisent », avait confié au Monde, amusé, le photographe. June Newton le répète sans cesse à José Alvarez. Marie-Claude Beaud pense savoir pourquoi : « Newton condense ce que le monde de l'art méprise  : un rigolo et pas un cérébral, qui gagne beaucoup d'argent dans la mode en photographiant des filles dans des poses sexy. Pour moi, il est simplement un artiste hors norme ».&quot;

Même constat pour Françoise Marquet, qui a organisé la première grande exposition Newton dans un musée, au Musée d'art moderne de la Ville de Paris, en 1984. « Les gens faisaient la tête quand ils voyaient des photos dans un musée. Newton était jalousé à cause de sa réussite, de sa façon de jouer au dandy ». Les choses ont changé, note Didier Grumbach, président de la Fédération française de la couture, qui voit « se multiplier les passerelles entre l'art et la mode ». Mais les  musées français sont à la traîne.

Pour voir des Newton en France, il faut aller à la Maison européenne de la photographie (MEP), qui dépend de la Ville de Paris. [[Jean-Luc Monterosso]], directeur de la MEP, conserve 75 œuvres de Newton, notamment cinq Big Nudes - dont trois donnés - et le fameux diptyque Sie kommen, Naked &amp; Dressed (1981). Ces acquisitions, à des prix « très avantageux », dit Monterosso, balaient deux poncifs à propos de Newton : il était cher et capricieux. « Notre collection est le résultat d'une relation privilégiée,
d'une amitié de vingt ans », explique Jean-Luc Monterosso. Cette remarque renvoie aux dernières lignes écrites par Newton dans son
autobiographie (Autoportrait, éd. Robert Laffont), dans laquelle il évoque en ces termes le maire de Berlin, Klaus Wowereit : « Il me porte dans son cœur ».

Dans l'affaire de la donation en France, « Helmut ne s'est pas senti aimé et s'est dit trompé », accuse José Alvarez. Le ministre de la culture, Jean-Jacques Aillagon, a dit dans Le Monde du 31 janvier qu'il souhaitait « rendre hommage » à Newton pour l'ouverture du Jeu de paume. Beaucoup d'observateurs pensent que ce serait désormais « le sommet du ridicule ». Et il n'est pas sûr que June Newton apprécie. Le groupe de presse américain Conde Nast (Vogue) envisage, pour sa part, un hommage à
Newton le 5 juillet à Paris, pendant les défilés de mode. Il aurait lieu au Théâtre du Palais-Royal. Juste en face du ministère de la culture.


{{Ph Personnalités}}

{{DEFAULTSORT:Newton, Helmut}}

[[Catégorie:Personnalités de la photographie]]</text>
      <sha1>l564aaidif529xgkh9j671ln3pe26lb</sha1>
    </revision>
  </page>
  <page>
    <title>CMC/4e/Équation, ordre</title>
    <ns>0</ns>
    <id>23619</id>
    <revision>
      <id>684278</id>
      <parentid>560212</parentid>
      <timestamp>2022-08-27T18:18:46Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3628" xml:space="preserve">Une équation consiste en deux expressions séparées par le signe égal (=). Tout ce qui est à gauche est égal à tout ce qui se trouve à droite, par exemple 2 + 3 = 4 + 1. Certaines équations contiennent une variable, souvent notée x ou y, bien que n'importe quel symbole puisse être utilisé.

==Manipuler les expressions==

Parfois, les expressions sont désordonnées, et pourraient être présentées sous une forme plus simple. Les notions abordées ici sont essentielles pour le reste du cours.

===Rassembler les termes similaires===

Pour rassembler les termes similaires, il suffit d'additionner les termes en x, puis tous les termes en y, et de même pour tout symbole représentant une variable.


Par exemple, 2x + 4y + 8z − 3x − 7y − 2z + 4x devient:

2x − 3x + 4x = 3x

4y − 7y = − 3y

8z − 2z = 6z

Donc en additionnant les termes 2x + 4y + 8z − 3x − 7y − 2z + 4x est simplifié en : 3x − 3y + 6z.

=== Multiplication ===

La multiplication de différentes variables telles que &lt;math&gt;a \times b&lt;/math&gt; donne &lt;math&gt;ab&lt;/math&gt;. La multiplication de deux variables identiques augmente le degré de celle ci :&lt;math&gt; x \times x&lt;/math&gt; devient &lt;math&gt;x^2&lt;/math&gt;.

Comme pour l'addition et la soustraction, on rassemble les termes de même nature :
&lt;math&gt;2x^2z \times 3yz^2 \times 4xy^3&lt;/math&gt; devient: &lt;math&gt;24{x^3}{y^4}{z^3}&lt;/math&gt;

===Fractions===

Il est assez fréquent de rencontrer des fractions. Il est donc nécessaire d'apprendre à les manipuler correctement. La technique est de mettre toutes les fractions au même dénominateur et de les rassembler en une seule fraction. Il faut multiplier le numérateur et le dénominateur pour que la fraction garde la même valeur.
Par exemple pour &lt;math&gt;\frac {3x}{2} + \frac {2y}{5} - \frac {z}{10}&lt;/math&gt;, le dénominateur commun est &lt;math&gt;10&lt;/math&gt;.

On multiplie en haut et en bas par &lt;math&gt;5&lt;/math&gt;: &lt;math&gt;\frac {15x}{10}&lt;/math&gt;

On multiplie en haut et en bas par &lt;math&gt;2&lt;/math&gt;: &lt;math&gt;\frac {4y}{10}&lt;/math&gt;
	
On ne change rien : &lt;math&gt;\frac {z}{10}&lt;/math&gt;

Maintenant nous avons &lt;math&gt;\frac {15x}{10} + \frac{ 4y}{10} - \frac {z}{10}&lt;/math&gt;, qui devient &lt;math&gt;\frac {15x+4y-z}{10}&lt;/math&gt;.

==Résolution d'équations==

Souvent, il est nécessaire de réarranger une équation pour la résoudre, afin d'isoler l'inconnue d'un côté du signe égal. En réarrangeant &lt;math&gt;2 + x = 5&lt;/math&gt; en &lt;math&gt;x = 5 - 2&lt;/math&gt;, &lt;math&gt;x&lt;/math&gt; a été isolé. Maintenant, en simplifiant l'équation, on peut trouver la solution : &lt;math&gt;x=3&lt;/math&gt;.

Une équation à une variable sera vraie uniquement pour certaines valeurs de cette variable. Celles-ci sont appelée '''solutions''' de l'équation.
Par exemple &lt;math&gt;2 + x = 5&lt;/math&gt; est vraie seulement pour &lt;math&gt;x=3&lt;/math&gt;. Donc &lt;math&gt;x=3&lt;/math&gt; est la solution de l'équation &lt;math&gt;2 + x = 5&lt;/math&gt;.

===Isoler une autre variable===

Les équations sont souvent beaucoup plus compliquées que les exemples ci-dessus. Pour faire passer un terme de l'autre côté du signe égal, il faut appliquer les mêmes opérations de chaque côté. Par exemple, pour isoler &lt;math&gt;x&lt;/math&gt; dans l'équation &lt;math&gt;y = \frac{4 a (x^2 +b)}{3}&lt;/math&gt; :


{| cellpadding=&quot;10&quot;
|Multiplier des deux côtés par &lt;math&gt;3&lt;/math&gt;
|&lt;math&gt;3y = 4 a (x^2 + b)&lt;/math&gt;
|-
|Diviser des deux côtés par &lt;math&gt;4a&lt;/math&gt;
|&lt;math&gt;\frac {3y}{4a} = x^2 + b&lt;/math&gt;
|-
|Soustraire &lt;math&gt;b&lt;/math&gt; des deux côtés
|&lt;math&gt;\frac {3y}{4a} -b = x^2&lt;/math&gt;
|-
|Prendre la racine carré de chaque côté
|&lt;math&gt;\sqrt{\frac {3y}{4a} -b } = x&lt;/math&gt;
|x est alors isolé
|}

[[Catégorie:Cours de mathématiques niveau quatrième (France)]]</text>
      <sha1>rltynqxkyfh4fc4sh1c1xjvytgmo1vs</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Chaines de caractères</title>
    <ns>0</ns>
    <id>23924</id>
    <revision>
      <id>684244</id>
      <parentid>670113</parentid>
      <timestamp>2022-08-27T12:56:41Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="30249" xml:space="preserve">&lt;noinclude&gt;{{Python}}&lt;/noinclude&gt;

== Les données alphanumériques ==
{{Principe|titre=Pour les non-programmeurs|contenu=
Les chaînes de caractères (&quot;string&quot; en anglais) sont des listes de caractères. On parle de chaînage car les caractères se suivent et chaque caractère a sa place, comme les maillons d'une chaîne. Il est ainsi possible de faire apparaître plusieurs fois le même caractère dans une chaîne, afin de manipuler des phrases par exemple. 
}}

À la différence des données numériques, qui sont des entités singulières, les chaînes de caractères (ou string) constituent un ''type de donnée composite''. Nous entendons par là une entité bien définie qui est faite elle-même d'un ensemble d'entités plus petites, en l'occurrence : les caractères. Suivant les circonstances, nous serons amenés à traiter une telle donnée composite, tantôt comme un seul objet, tantôt comme une suite ordonnée d'éléments. Dans ce dernier cas, nous souhaiterons probablement pouvoir accéder à chacun de ces éléments à titre individuel.

En fait, les chaînes de caractères font partie d'une catégorie d'objets Python que l'on appelle des ''séquences'', et dont font partie aussi les ''listes'' et les ''tuples''.

=== Le type « string » ===

Sous Python, une donnée de type ''string'' est une suite quelconque de caractères délimitée soit par des apostrophes (''simple quotes''), soit par des guillemets (''double quotes''), soit par des ''triples quotes'' (&lt;nowiki&gt;''' ou &quot;&quot;&quot;&lt;/nowiki&gt;).

Exemples :

&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; phrase1 = 'les œufs durs.'
&gt;&gt;&gt; phrase2 = '&quot;Oui&quot;, répondit-il,'
&gt;&gt;&gt; phrase3 = &quot;j'aime bien&quot;
&gt;&gt;&gt; print(phrase2, phrase3, phrase1)
&quot;Oui&quot;, répondit-il, j'aime bien les œufs durs.

print(&quot;&quot;&quot;1, &quot; 2&quot;, \n 3,
4&quot;&quot;&quot;)
&lt;/syntaxhighlight&gt;

Résultat :
&lt;syntaxhighlight lang=&quot;shell&quot;&gt;
1, &quot; 2&quot;, 
 3,
4
&lt;/syntaxhighlight&gt;

Les trois variables &lt;code&gt;phrase1&lt;/code&gt;, &lt;code&gt;phrase2&lt;/code&gt;, &lt;code&gt;phrase3&lt;/code&gt; sont donc des variables de type ''string''.

== Accès aux caractères individuels d'une chaîne ==

Les chaînes de caractères constituent un cas particulier d'un type de données plus général que l'on appelle des ''données composites''.  Une donnée composite est une entité qui rassemble dans une seule structure un ensemble d'entités plus simples : dans le cas d'une chaîne de caractères, par exemple, ces entités plus simples sont évidemment les caractères eux-mêmes. En fonction des circonstances, nous souhaiterons traiter la chaîne de caractères, tantôt comme un seul objet, tantôt comme une collection de caractères distincts. Un langage de programmation tel que Python doit donc être pourvu de mécanismes qui permettent d'accéder séparément à chacun des caractères d'une chaîne.

Python considère qu'une chaîne de caractères est un objet de la catégorie des séquences, lesquelles sont des ''collections ordonnées d'éléments''. Cela signifie simplement que les caractères d'une chaîne sont toujours disposés dans un certain ordre. Par conséquent, chaque caractère de la chaîne peut être désigné par sa place dans la séquence, à l'aide d'un index.

Pour accéder à un caractère bien déterminé, on utilise le nom de la variable qui contient la chaîne, et on lui accole entre deux crochets l'index numérique qui correspond à la position du caractère dans la chaîne.

{{remarque|Comme vous aurez l'occasion de le vérifier par ailleurs, les données informatiques sont presque toujours numérotées à partir de zéro (et non à partir de un). C'est le cas pour les caractères d'une chaîne. 
''Exemple :''
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; chaine = &quot;Stéphanie&quot;
&gt;&gt;&gt; print(chaine[0], chaine[3])
S p
&lt;/syntaxhighlight&gt;
}}


== Taille des chaines ==
* Déterminer la longueur (c'est-à-dire le nombre de caractères) d'une chaîne, en faisant appel à la fonction intégrée &lt;code&gt;len()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; print(len(c))
29 #La chaîne de caractères 'c' contient 29 caractères !

&gt;&gt;&gt; print(len('Zowerz'))
6
&lt;/syntaxhighlight&gt;

== Sous-chaines ==
L'opérateur d'indiçage ([]) permet aussi de sélectionner des sous-chaines selon leurs indices. On appelle cette technique le ''slicing'' (« découpage en tranches »).

Dans la tranche &lt;code&gt;[n,m]&lt;/code&gt;, le n&lt;sup&gt;ième&lt;/sup&gt; caractère est inclus, mais pas le m&lt;sup&gt;ième&lt;/sup&gt;. Si vous voulez mémoriser aisément ce mécanisme, il faut vous représenter que les indices pointent des emplacements situés entre les caractères, comme dans le schéma ci-dessous :

[[Fichier:Apprendre à programmer avec Python 31.png|center|illustration du système de numérotation des caractères]]

Au vu de ce schéma, il n'est pas difficile de comprendre que &lt;code&gt;ch[3:7]&lt;/code&gt; extraira &lt;code&gt;iett&lt;/code&gt;. Notez qu'il faut impérativement utiliser un deux-points (:) : l'utilisation d'une virgule ou d'un point-virgule retournera une erreur.

De plus, si la borne de départ est le premier caractère (indice 0) ou si celle d'arrivée est la dernière (indice égal à la longueur de la chaine), il devient facultatif. Une borne négative ''-x'' prendra le ''x''-ième caractère en partant de la fin, ainsi -1 désignera le dernier caractère, -2 l'avant-dernier, -3 l’antépénultième, etc. Cela ne marche pas avec [-0], qui retournera le premier caractère car -0 = +0. Exemple :
&lt;syntaxhighlight lang=python&gt;
&gt;&gt;&gt; chain = &quot;123456789&quot;
&gt;&gt;&gt; print(chain[1:3])
23

&gt;&gt;&gt; print(chain[0:-1])
12345678
&gt;&gt;&gt; print(chain[:-1])
12345678

&gt;&gt;&gt; print(chain[1:len(chain)])
23456789
&gt;&gt;&gt; print(chain[1:])
23456789
&lt;/syntaxhighlight&gt;

Pour une chaîne de caractère &lt;code&gt;chaine&lt;/code&gt;, les indices doivent être compris entre &lt;code&gt;-len(chaine)&lt;/code&gt; et &lt;code&gt;+len(chaine)-1&lt;/code&gt;.
En dehors de cet intervalle, l'interpréteur retourne le message d'erreur suivant :
 IndexError: string index out of range

Pour vérifier le début et la fin d'une chaine sans avoir à déterminer sur quelle longueur , on peut utiliser &quot;startswith()&quot; et &quot;endswith()&quot;, mais c'est moins rapide car faisant appel à une fonction de plus haut niveau. {{refnec}}

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
if chain.startswith('1234'):
    print('ok')
if chain.endswith('89'):
    print('ok')
&lt;/syntaxhighlight&gt;

== Concaténation ==
L'opération d'assembler plusieurs petites chaînes pour en construire une plus grande s'appelle ''concaténation'' et on la réalise sous Python à l'aide de l'opérateur &quot;+&quot;. Exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 'Petit poisson'
b = ' deviendra grand'
c = a + b
print(c)
&lt;/syntaxhighlight&gt;
 petit poisson deviendra grand

Pour convertir en nombre véritable une chaîne de caractères qui représente un nombre. Exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; chaine = '8647'              
&gt;&gt;&gt; print(chaine + 45)
   ==&gt; *** erreur *** on ne peut pas additionner une chaîne et un nombre 

&gt;&gt;&gt; print(int(chaine) + 65)
8712                         # OK : on peut additionner deux nombres

&gt;&gt;&gt; print(chaine + str(65))
864765                       # OK : on peut concaténer deux chaines
&lt;/syntaxhighlight&gt;

Dans cet exemple, la fonction intégrée &lt;code&gt;int()&lt;/code&gt; convertit la chaîne en nombre entier, et &lt;code&gt;str()&lt;/code&gt; convertit l'entier en chaine.


== Parcours d'une séquence : for... in... ==

Il arrive très souvent que l'on doive traiter l'intégralité d'une chaîne caractère par caractère, du premier jusqu'au dernier, pour effectuer à partir de chacun d'eux une opération quelconque.  Nous appellerons cette opération un ''parcours''.  En nous limitant aux outils Python que nous connaissons déjà, nous pouvons envisager d'encoder un tel parcours sur la base de l'instruction &lt;code&gt;while&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;python3&quot; highlight=&quot;2,3,5&quot;&gt;
nom = 'Jacqueline'
index = 0
while index &lt; len(nom):
    print(nom[index], '*', end='')   # En Python 2: print(nom[index] + ' *'), 
    index = index + 1
&lt;/syntaxhighlight&gt;

Cette boucle « parcourt » donc la chaîne nom pour en extraire un à un tous les caractères, lesquels sont ensuite imprimés avec interposition d'astérisques. Notez bien que la condition utilisée avec l'instruction while est &lt;code&gt;index &lt; len(nom)&lt;/code&gt;, ce qui signifie que le bouclage doit s'effectuer jusqu'à ce que l'on soit arrivé à l'indice numéro 9 (la chaîne compte en effet 10 caractères).  Nous aurons effectivement traité tous les caractères de la chaîne, puisque ceux-ci sont indicés de ''zéro'' à 9.

Le parcours d'une séquence est une opération très fréquente en programmation. Pour en faciliter l'écriture, Python vous propose une structure de boucle plus appropriée, basée sur le couple d'instructions &lt;code&gt;for ... in ...&lt;/code&gt; :

Avec ces instructions, le programme ci-dessus devient :

&lt;syntaxhighlight lang=&quot;python3&quot; highlight=&quot;2&quot;&gt;
nom = 'Jacqueline'
for character in nom:
    print(character, '*', end='')   # En Python 2: print(character + ' *'),
&lt;/syntaxhighlight&gt;

Comme vous pouvez le constater, cette structure de boucle est plus compacte. Elle vous évite d'avoir à définir et à incrémenter une variable spécifique (un « compteur ») pour gérer l'indice du caractère que vous voulez traiter à chaque itération. La variable &lt;code&gt;caract&lt;/code&gt; contiendra successivement tous les caractères de la chaîne, du premier jusqu'au dernier.

L'instruction for permet donc d'écrire des boucles, dans lesquelles ''l'itération traite successivement tous les éléments d'une séquence donnée''. Dans l'exemple ci-dessus, la séquence était une chaîne de caractères. L'exemple ci-après démontre que l'on peut appliquer le même traitement aux listes :

&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
liste = ['chien','chat','crocodile']
for animal in liste:
    print('longueur de la chaîne', animal, '=', len(animal))
&lt;/syntaxhighlight&gt;

L'exécution de ce script donne :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
longueur de la chaîne chien = 5
longueur de la chaîne chat = 4
longueur de la chaîne crocodile = 9
&lt;/syntaxhighlight&gt;

L'instruction &lt;code&gt;for&lt;/code&gt; est un nouvel exemple d’''instruction composée''. N'oubliez donc pas le double point obligatoire à la fin de la ligne, et l'indentation du bloc d'instructions qui suit.

Le nom qui suit le mot réservé  in  est celui de la séquence qu'il faut traiter. Le nom qui suit le mot réservé  for  est celui que vous choisissez pour la variable destinée à contenir successivement tous les éléments de la séquence. Cette variable est définie automatiquement (c'est-à-dire qu'il est inutile de la définir au préalable), et son type est automatiquement adapté à celui de l'élément de la séquence qui est en cours de traitement.

Exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
divers = ['cheval', 3, 17.25, [5, 'Jean']]
for e in divers:
    print(e)
&lt;/syntaxhighlight&gt;

L'exécution de ce script donne :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
cheval
3
17.25
[5, 'Jean']
&lt;/syntaxhighlight&gt;

Bien que les éléments de la liste divers soient tous de types différents (une chaîne de caractères, un entier, un réel, une liste), on peut affecter successivement leurs contenus à la variable e, sans qu'il s'ensuive des erreurs (ceci est rendu possible grâce au typage dynamique des variables Python).


{{exercices}}
# Écrivez un script qui détermine si une chaîne contient ou non le caractère « e ».
# Écrivez un script qui compte le nombre d'occurrences du caractère « e » dans une chaîne.
# Écrivez un script qui recopie une chaîne (dans une nouvelle variable), en insérant des astérisques entre les caractères.&lt;br /&gt;Ainsi par exemple, « gaston » devra devenir « g*a*s*t*o*n »
# Écrivez un script qui recopie une chaîne (dans une nouvelle variable) en l'inversant.&lt;br /&gt;Ainsi par exemple, « zorglub » deviendra « bulgroz ».
# En partant de l'exercice précédent, écrivez un script qui détermine si une chaîne de caractères donnée est un palindrome (c'est-à-dire une chaîne qui peut se lire indifféremment dans les deux sens), comme par exemple « radar » ou « s.o.s ».
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Recherche d'un caractère particulier dans une chaîne

# Chaîne fournie au départ :
chain = &quot;Monty python flying circus&quot;
# Caractère à rechercher :
letter = &quot;e&quot;
# Recherche proprement dite :
i = 0   # indice du caractère en cours d'examen
found = False   # &quot;drapeau&quot; à lever si le caractère recherché est présent
while i &lt; len(chain):
    if chain[i] == letter:
        found = True
    i = i + 1

# Affichage :
print(u&quot;Le caractère&quot;, letter)  # Le caractère e
if found == 1:
    print(u&quot;est présent&quot;)
else:
    print(u&quot;est introuvable&quot;)
print(u&quot;dans la chaîne&quot;, chain)  # dans la chaîne Monty python flying circus
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Insertion d'un caractère d'espacement dans une chaîne

# Chaîne fournie au départ :
ch = &quot;Gaston&quot;
# Caractère à insérer :
cr = &quot;*&quot;
# Le nombre de caractères à insérer est inférieur d'une unité au
# nombre de caractères de la chaîne. On traitera donc celle-ci à
# partir de son second caractère (en omettant le premier).
lc = len(ch)    # nombre de caractères total
i = 1           # indice du premier caractère à examiner (le second, en fait)
nch = ch[0]     # nouvelle chaîne à construire (contient déjà le premier caractère)
while i &lt; lc:
    nch = nch + cr + ch[i]
    i = i + 1    
# Affichage :
print(nch)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Inversion d'une chaîne de caractères

# Chaîne fournie au départ :
ch = &quot;zorglub&quot;
lc = len(ch)    # nombre de caractères total
i = lc - 1      # le traitement commencera à partir du dernier caractère
nch = &quot;&quot;        # nouvelle chaîne à construire (vide au départ)
while i &gt;= 0:
    nch = nch + ch[i]
    i = i - 1    
# Affichage :
print(nch)  
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;li&gt;Réfléchissez !&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

{{Exercices}}
&lt;ol&gt;
&lt;li&gt;Dans un conte américain, huit petits canetons s'appellent respectivement : Jack, Kack, Lack, Mack, Nack, Oack, Pack et Qack. Écrivez un script qui génère tous ces noms à partir des deux chaînes suivantes :
* &lt;code&gt;prefixes = 'JKLMNOPQ'&lt;/code&gt;
* &lt;code&gt;suffixe = 'ack'&lt;/code&gt;

Si vous utilisez une instruction &lt;code&gt;for... in...&lt;/code&gt; , votre script ne devrait comporter que deux lignes.
&lt;/li&gt;

&lt;li&gt;Rechercher le nombre de mots contenus dans une phrase donnée.&lt;/li&gt;
&lt;/ol&gt;
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
prefixes, suffixe = &quot;JKLMNOPQ&quot;, &quot;ack&quot;

for p in prefixes:
    print p + suffixe
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
    # Comptage du nombre de mots dans &quot;chain&quot;
    chain = &quot;Les petits ruisseaux font les grandes rivières&quot;
    if len(chain) == 0:
        print(0)
    nm = 1                  # la chaîne comporte au moins un mot          
    for c in chain:
        if c == &quot; &quot;:        # il suffit de compter les espaces
            nm = nm + 1
    print(nm)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

== Appartenance d'un élément à une séquence : if.. in... ==

L'instruction &lt;code&gt;in&lt;/code&gt; peut être utilisée indépendamment de &lt;code&gt;for&lt;/code&gt;, pour vérifier si un élément donné fait partie ou non d'une séquence. Vous pouvez par exemple vous servir de &lt;code&gt;in&lt;/code&gt; pour vérifier si tel caractère alphabétique fait partie d'un groupe bien déterminé :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
car = &quot;e&quot;
voyelles = &quot;aeiouyAEIOUY&quot;
if car in voyelles:
    print (car, &quot;est une voyelle&quot;)
&lt;/syntaxhighlight&gt;

D'une manière similaire, vous pouvez vérifier l'appartenance d'un élément à une liste :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
n = 5
nombrePremiers = [1, 2, 3, 5, 7, 11, 13, 17]
if  n in nombrePremiers:
    print(n, &quot;fait partie de notre liste de nombres premiers&quot;)
&lt;/syntaxhighlight&gt;

Cette instruction très puissante effectue donc à elle seule un véritable parcours de la séquence. À titre d'exercice, écrivez les instructions qui effectueraient le même travail à l'aide d'une boucle classique utilisant l'instruction &lt;code&gt;while&lt;/code&gt;.

{{Exercices}}
# Écrivez un script qui affiche « vrai » si un caractère est un chiffre.
# Écrivez un script qui affiche « vrai » si un caractère est une majuscule.
{{solution}}
&lt;ol&gt;
&lt;/li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
    if character in &quot;0123456789&quot;:
        print(True)
    else:
        print(False)
&lt;/syntaxhighlight&gt;
&lt;li&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
    if character in &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;:
        print True
    else:
        print False
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

== Les chaînes sont des séquences non modifiables ==

Vous ne pouvez pas modifier le contenu d'une chaîne existante. En d'autres termes, vous ne pouvez pas utiliser l'opérateur [] dans la partie gauche d'une instruction d'affectation.  Essayez par exemple d'exécuter le petit script suivant (qui cherche à remplacer une lettre dans une chaîne) :

&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
salut = 'bonjour à tous'
salut[0] = 'B'
print (salut)
&lt;/syntaxhighlight&gt;

Au lieu d'afficher « Bonjour à tous », ce script « lève » une erreur du genre : &lt;code&gt;TypeError: object doesn't support item assignment&lt;/code&gt;. Cette erreur est provoquée à la deuxième ligne du script. On y essaie de remplacer une lettre par une autre dans la chaîne, mais cela n'est pas permis.

Par contre, le script ci-dessous fonctionne :

&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
salut = 'bonjour à tous'
salut = 'B' + salut[1:]
print (salut)
&lt;/syntaxhighlight&gt;

Dans cet autre exemple, en effet, nous ne modifions pas la chaîne &quot;salut&quot;. Nous en recréons une nouvelle avec le même nom à la deuxième ligne du script (à partir d'un morceau de la précédente, soit, mais qu'importe : il s'agit bien d'une ''nouvelle'' chaîne).

== Les chaînes sont comparables ==

Tous les opérateurs de comparaison dont nous avons parlé à propos des instructions de contrôle de flux (c'est-à-dire les instructions &lt;code&gt;if ... elif ... else&lt;/code&gt;) fonctionnent aussi avec les chaînes de caractères. Cela vous sera très utile pour trier des mots par ordre alphabétique :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
mot = raw_input(&quot;Entrez un mot quelconque : &quot;)
if mot &lt; &quot;limonade&quot;:
    place = &quot;précède&quot;
elif mot &gt; &quot;limonade&quot;:
    place = &quot;suit&quot;
else:
    place = &quot;se confond avec&quot;
print(&quot;Le mot&quot;, mot, place, &quot;le mot 'limonade' dans l'ordre alphabétique&quot;)
&lt;/syntaxhighlight&gt;

Ces comparaisons sont possibles, parce que les caractères alphabétiques qui constituent une chaîne de caractères sont mémorisés dans la mémoire de l'ordinateur sous forme de nombres binaires dont la valeur est liée à la place qu'occupe le caractère dans l'alphabet. Dans le système de codage ASCII, par exemple, A=65, B=66, C=67, etc.


== Encodage ==

En python 2, pour encoder une chaîne en Unicode, il faut la préfixer par la lettre &quot;u&quot;&lt;ref&gt;https://docs.python.org/2/tutorial/introduction.html#unicode-strings&lt;/ref&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; string = u&quot;il était une fois&quot;
&gt;&gt;&gt; print(string)
'il était une fois'
&lt;/syntaxhighlight&gt;

En python 3, les chaînes de caractères sont en Unicode par défaut.
Le préfixe u est donc facultatif.
Il reste présent et utile si le programme doit pouvoir fonctionner à la fois en Python 2 et en Python 3.

Au sujet des chaînes de caractères, il est important de savoir que deux notions différentes de chaînes de caractères existent en Python.

Pour des raisons historiques dans les versions de Python inférieures à Python 2, on considérait une chaîne de caractère comme une chaîne d'octets. Ceci permettait d'avoir un seul type pour traiter de deux notions différentes, mais pouvait parfois engendrer de la confusion sur le type traité.
* Le type String contenait à la fois une séquence d'octet et une chaîne de caractères ASCII/UTF-8 (exemple : &quot;Hello World&quot;).

Depuis la version 3 de Python, les types chaînes d'octet et chaîne de caractères sont clairement différenciées.
* Le type chaîne de caractères (classe &lt;code&gt;str&lt;/code&gt;) contient des caractères Unicode (exemple: 'xyzzy', &quot;frobozz&quot;) 
* Les octets et tableaux d'octets (classes &lt;code&gt;bytes&lt;/code&gt; et &lt;code&gt;bytearray&lt;/code&gt;) ne contiennent que des octets (l'un est {{wt|immutable}} alors que l'autre est mutable). Exemple : b'xyzzy'.

Pour résumer :

{|
! Version de Python
! Python 2
! Python 3
|-
! Chaîne de caractères unicode
|
&lt;syntaxhighlight lang=&quot;python2&quot;&gt;
# Classe unicode
s = u&quot;abc&quot;
s     # u'abc'
s[1]  # u&quot;b&quot;
&lt;/syntaxhighlight&gt;
| 
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
# Classe str
s = &quot;abc&quot;  #  ou  s = u&quot;abc&quot;
s     # 'abc'
s[1]  # &quot;b&quot;
&lt;/syntaxhighlight&gt;
|-
! Chaîne d'octets
|
&lt;syntaxhighlight lang=&quot;python2&quot;&gt;
# Classe str
s = &quot;abc&quot;
s     # 'abc'
s[1]  # &quot;b&quot;
&lt;/syntaxhighlight&gt;
| 
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
# Classe bytes
s = b&quot;abc&quot;
s     # b'abc'
s[1]  # 98
&lt;/syntaxhighlight&gt;
|}

La différence de comportement est illustrée dans le tableau comparatif ci-dessous.

{|
! Code
! Résultat en Python 2
! Résultat en Python 3
|-
| &lt;syntaxhighlight lang=&quot;python3&quot;&gt;
a = 'test'
type(a)
b = u'test'
type(b)
c = b'test'
type(c)
&lt;/syntaxhighlight&gt;
| &lt;pre&gt;

str

unicode

str
&lt;/pre&gt;
| &lt;pre&gt;

str

str

bytes
&lt;/pre&gt;
|-
| &lt;syntaxhighlight lang=&quot;python3&quot;&gt;
a == b
a == c
b == c
&lt;/syntaxhighlight&gt;
| &lt;pre&gt;
True
True
True
&lt;/pre&gt;
| &lt;pre&gt;
True
False
False
&lt;/pre&gt;
|}

== Classement des caractères ==

Il est souvent utile de pouvoir déterminer si tel caractère extrait d'une chaîne est une lettre majuscule ou minuscule, ou plus généralement encore, de déterminer s'il s'agit bien d'une lettre, d'un chiffre, ou encore d'un autre caractère typographique.

Nous pouvons bien entendu écrire différentes fonctions pour assurer ces tâches. Une première possibilité consiste à utiliser l'instruction &quot;in&quot;. Mais puisque nous savons désormais que les caractères forment une suite bien ordonnée dans le code ASCII, nous pouvons exploiter d'autres méthodes. Par exemple, pour déterminer si on a affaire à une minuscule :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
    if 'a' &lt;= character &lt;= 'z' :
        print('bas de casse')
    else:
        print('haut de casse')
&lt;/syntaxhighlight&gt;

{{Exercices}}
# Écrivez un script qui affiche « vrai » si l'argument transmis est un chiffre (avec une autre méthode que celles exploitées précédemment)
# Écrivez un script qui affiche « vrai » si un caractère est une majuscule
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
    if character &gt;= &quot;0&quot; and character &lt;= &quot;9&quot;:
        print(True)
    else:
        print(False)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
    if character &gt;= &quot;A&quot; and character &lt;= &quot;Z&quot;:
        print(True)
    else:
        print(False)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

Afin que vous puissiez effectuer plus aisément toutes sortes de traitements sur les caractères, Python met à votre disposition un certain nombre de fonctions prédéfinies :

* La fonction &lt;code&gt;ord(character)&lt;/code&gt; accepte n'importe quel caractère comme argument. En retour, elle fournit le code ASCII correspondant à ce caractère. Ainsi &lt;code&gt;ord('A')&lt;/code&gt;  renvoie la valeur &lt;code&gt;65&lt;/code&gt;, et &lt;code&gt;ord(u'é')&lt;/code&gt; 233.

* La fonction &lt;code&gt;chr(number)&lt;/code&gt; fait exactement le contraire. L'argument qu'on lui transmet doit être un entier compris entre 0 et 255. En retour, on obtient le caractère ASCII correspondant. Ainsi &lt;code&gt;chr(65)&lt;/code&gt; renvoie le caractère &lt;code&gt;A&lt;/code&gt;.

{{Exercices}}
# Écrivez un petit script qui affiche une table des codes ASCII. Le programme doit afficher tous les caractères en regard des codes correspondants. À partir de cette table, établissez les relations numériques reliant chaque caractère majuscule à chaque caractère minuscule.   
# À partir des relations trouvées, écrivez un script qui convertit tous les caractères d'une phrase donnée en capitales.
# À partir des mêmes relations, écrivez un script qui convertit tous les caractères d'une phrase en capitales.
# Écrivez un script qui compte le nombre de fois qu'apparaît tel caractère (fourni en argument) dans une phrase donnée. 
# Écrivez un script qui affiche le nombre de voyelles contenues dans une phrase donnée.
{{solution}}
&lt;ol&gt;
&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Table des codes ASCII :
c = 32          # Premier code ASCII &lt;imprimable&gt;
while c &lt; 128 : # caractères non accentués seulement 
    print(&quot;Code&quot;), c, &quot;:&quot;, chr(c), &quot;  &quot;,
    c = c + 1
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Convertir majuscules -&gt; minuscules et inversement :
    # Échange les majuscules et les minuscules de &quot;chaine&quot;
    chain = &quot;Ferdinand-Charles de CAMARET&quot;
    newChain = &quot;&quot;                   # chaîne à construire
    for car in chain:
        code = ord(car)
        if car &gt;= &quot;A&quot; and car &lt;= &quot;Z&quot;:
            code = code + 32
        elif car &gt;= &quot;a&quot; and car &lt;= &quot;z&quot;:
            code = code - 32
        newChain = newChain + chr(code)
    print(newChain)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;

&lt;li&gt;Réfléchissez !&lt;/li&gt;

&lt;li&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Comptage de voyelles :
    # Teste si car est une voyelle&quot;
    if character in &quot;AEIOUYaeiouy&quot;:
        print(True)
    else:
        print(False)

    # Compte les voyelles présentes dans la chaîne &quot;chaine&quot;
    n = 0
    for c in chaine:
        if voyelle(c):
            n = n + 1
    print(n)
&lt;/syntaxhighlight&gt;
&lt;/li&gt;
&lt;/ol&gt;
{{fin}}

== Méthodes des objets string ==
Sous Python, les chaînes de caractères sont des objets. On peut donc effectuer de nombreux traitements dessus en utilisant des méthodes appropriées. En voici quelques-unes, choisies parmi les plus utiles. Mais vous pouvez obtenir la liste complète de toutes les méthodes associées à un objet à l'aide de la fonction intégrée &lt;code&gt;&lt;nowiki&gt;dir('')&lt;/nowiki&gt;&lt;/code&gt; ou &lt;code&gt;help(str)&lt;/code&gt; :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; dir('')
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
&lt;/syntaxhighlight&gt;

* Les fonctions &quot;str()&quot; et &quot;repr()&quot; (pour ''représentation'' d'objet) permettent de transformer un objet Python quelconque en chaîne de caractères. Ces deux fonctions sont différentes : &quot;str('chaine')&quot; retournera 'chaine' tandis que &quot;repr('chaine')&quot; retournera &quot;'chaine'&quot;.

* &lt;code&gt;index(c)&lt;/code&gt; : retrouve l'index de la première occurrence du caractère &quot;c&quot; dans la chaîne, ou déclenche une erreur si absent (''ValueError: substring not found'').
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; foin = &quot;Portez ce vieux whisky au juge blond qui fume&quot;
&gt;&gt;&gt; print (foin.index(&quot;w&quot;))
16
&lt;/syntaxhighlight&gt;

* &lt;code&gt;find(aiguille)&lt;/code&gt; : cherche la position d'une sous-chaîne &lt;code&gt;aiguille&lt;/code&gt; dans la chaîne, en partant du début.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; foin = &quot;Cette leçon vaut bien un fromage, sans doute ?&quot;
&gt;&gt;&gt; aiguille = &quot;fromage&quot;
&gt;&gt;&gt; print(foin.find(aiguille))
25
&lt;/syntaxhighlight&gt;

* &lt;code&gt;rfind(aiguille)&lt;/code&gt; : pareil que &quot;find&quot; mais en partant de la fin (reverse).
&lt;pre&lt;syntaxhighlight lang=&quot;python&quot;&gt;&gt;
&gt;&gt;&gt; foin = &quot;Cette leçon vaut bien deux fromages, dont un fromage râpé ?&quot;
&gt;&gt;&gt; aiguille = &quot;fromage&quot;
&gt;&gt;&gt; print(foin.rfind(aiguille))
46
&lt;/syntaxhighlight&gt;

* &lt;code&gt;count(aiguille)&lt;/code&gt; : compte le nombre de sous-chaînes &lt;code&gt;aiguille&lt;/code&gt; dans la chaîne.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; foin = &quot;Le héron au long bec emmanché d'un long cou&quot;
&gt;&gt;&gt; aiguille = 'long'
&gt;&gt;&gt; print(foin.count(aiguille))
2
&lt;/syntaxhighlight&gt;

* &lt;code&gt;lower()&lt;/code&gt; : convertit une chaîne en minuscules.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; phrase =&quot;ATTENTION : Danger !&quot;
&gt;&gt;&gt; print(phrase.lower())
attention : danger !
&lt;/syntaxhighlight&gt;

* &lt;code&gt;upper()&lt;/code&gt; : convertit une chaîne en majuscules.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; phrase = &quot;Merci beaucoup&quot;
&gt;&gt;&gt; print(phrase.upper())
MERCI BEAUCOUP
&lt;/syntaxhighlight&gt;

* &lt;code&gt;capitalize()&lt;/code&gt; : convertit en majuscule la première lettre d'une chaîne.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; phrase = &quot;quel beau temps, aujourd'hui !&quot;
&gt;&gt;&gt; print(phrase.capitalize())
&quot;Quel beau temps, aujourd'hui !&quot;
&lt;/syntaxhighlight&gt;

* &lt;code&gt;swapcase()&lt;/code&gt; : convertit toutes les majuscules en minuscules et vice-versa.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; phrase = &quot;La CIGALE et la FOURMI&quot;
&gt;&gt;&gt; print(phrase.swapcase())
lA cigale ET LA fourmi
&lt;/syntaxhighlight&gt;

* &lt;code&gt;strip()&lt;/code&gt; : enlève les espaces éventuels au début et à la fin de la chaîne (trime).
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; phrase = &quot;   Monty Python   &quot;
&gt;&gt;&gt; phrase.strip()
'Monty Python'
&lt;/syntaxhighlight&gt;

* &lt;code&gt;replace(old, new)&lt;/code&gt; : remplace tous les caractères &lt;code&gt;old&lt;/code&gt; par des caractères &lt;code&gt;new&lt;/code&gt; dans la chaîne.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; phrase = &quot;Si ce n'est toi c'est donc ton frère&quot;
&gt;&gt;&gt; print(phrase.replace(&quot; &quot;,&quot;_&quot;))
Si_ce_n'est_toi_c'est_donc_ton_frère
&lt;/syntaxhighlight&gt;


Dans la plupart de ces méthodes, il est possible de préciser quelle portion de la chaîne doit être traitée, en ajoutant des arguments supplémentaires.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; print(ch9.index(&quot;e&quot;))		# cherche à partir du début de la chaîne 
4							# et trouve le premier 'e'
&gt;&gt;&gt; print(ch9.index(&quot;e&quot;,5))		# cherche seulement à partir de l'indice 5
8							# et trouve le second 'e'
&gt;&gt;&gt; print(ch9.index(&quot;e&quot;,15))		# cherche à partir du caractère n° 15
29							# et trouve le quatrième 'e'
&lt;/syntaxhighlight&gt;

== Références ==
{{Références}}</text>
      <sha1>867f65qxshdefrz51pnnci2v2c4qznl</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/B/Louis Boutan</title>
    <ns>0</ns>
    <id>24012</id>
    <revision>
      <id>684314</id>
      <parentid>443035</parentid>
      <timestamp>2022-08-27T18:52:14Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8443" xml:space="preserve">{{Ph s Personnalités}}


'''Louis Marie-Auguste Boutan''' est un biologiste français (Versailles, 6 mars 1859 - Tigzirt, 6 avril 1934).

== Biographie ==
[[Fichier:Raco-Boutang.jpg|thumb|150px|Photographie faite par L Boutan de son ami, l'océanographe et biologiste [[w:fr:Emil Racoviță|Émile Racovitza]]  équipé d'un [[w:fr:scaphandre à casque|scaphandre à casque]],  en 1899 à [[w:fr:Banyuls-sur-Mer|Banyuls-sur-Mer]]]]

Après des études de biologie et d’histoire naturelle à la Faculté des Sciences de Paris, il devient Maître de Conférences dans ce même Établissement. 

En 1880, il fait partie de la délégation française qui participe à l'exposition universelle de Melbourne.

En 1884, il va étudier sur place pendant six étés la biologie marine au Laboratoire Arago de Banyuls-sur-Mer et travaille particulièrement sur un gastéropode marin, la fissurelle (''Diodora italica''). Ce mollusque ne survivant que quelques jours dans l'aquarium du Laboratoire, Louis Boutan décida de se faire scaphandrier pour étudier directement son développement au fond de la mer. La thèse qu'il rédigea à cette occasion, intitulée ''Recherches sur l'anatomie et le développement de la fissurelle. Comparaison de la fissurelle avec les types voisins'', lui permet d'obtenir son doctorat ès-sciences à Paris, en 1886.

C'est au cours de ces recherches qu'il fut littéralement émerveillé par la découverte des paysages sous-marins « avec leurs prairies aux hautes herbes, leurs escarpements de rochers aux cavités peuplées de toute une faune ». Ses travaux le feront considérer par la suite comme un précurseur dans le domaine de la [[ph_photographie subaquatique|photographie sous-marine]].

=== Le premier caisson rigide à pression compensée ===

Louis Boutan comprit que là où il restait suffisamment de lumière pour agir sur la rétine du plongeur, il devait être possible d'enregistrer une image photographique. En 1893, conscient des difficultés qu'il allait devoir surmonter, il entreprit avec son frère Auguste, ancien élève de l'École Centrale, de construire la première chambre photographique étanche. Il ne faut pas perdre de vue qu'à cette époque, les plus petits appareils utilisaient des plaques de 9 x 12 cm (les photos étaient tirées par contact et non agrandies, la visée se faisait sous le voile noir et la sensibilité des émulsions était très faible. En outre, avec des formats importants auxquels nous ne sommes plus guère habitués, l'obtention d'une [[profondeur de champ]] importante nécessitait l'usage de très faibles ouvertures relatives, de sorte que les poses étaient nécessairement très longues.

Le premier appareil utilisé en plongée fut une chambre 9 x 12 non extensible, de type ''Detektiv'', capable d'exposer successivement 6 plaques de verre. Cette chambre était logée dans une boîte parallélépipédique en cuivre dont le couvercle était rendu étanche par un joint de caoutchouc serré à l'aide d'arceaux métalliques. Cinq trous fermés par des plaques de verre étaient destinés à l'objectif et aux divers viseurs. Deux passages étanches permettaient de commander l'obturateur et le changement des plaques. La mise au point et l'ouverture du diaphragme étaient fixés à l'avance, avant l'immersion du caisson.

Afin d'éviter les effets de la pression de l'eau sur le caisson, celui-ci était relié par un tube à un ballon externe rempli d'air et qui se comprimait au fur et à mesure de la descente, de façon à assurer automatiquement l'égalité des pressions internes et externes, limitant ainsi les risques d'entrée d'eau. Pour compléter le tout, un trépied en fer forgé à branches coulissantes permettait d'installer la chambre de façon stable, ce qui était évidemment indispensable en raison des temps de pose pouvant aller de 5 à 30 minutes. Les premières photos subaquatiques furent prises entre 3,5 et 11 m de fond.

Par la suite, encouragé par les premiers résultats, Louis Boutan fit construire un second appareil amphibie de plus grand format, 18 x 24 cm, et muni d'un objectif plus lumineux permettant de réaliser des photographies « instantanées ».

=== La première lampe photo sous-marine ===

La lumière solaire était suffisante pour opérer à 3 ou 4 mètres sous l'eau mais aux plus grandes profondeurs, l'absorption trop forte nécessitait le recours à un éclairage artificiel. 

L'idée d'utiliser la lumière électrique fut vite abandonnée car les techniques encore rudimentaires à l'époque auraient nécessité des moyens techniques beaucoup trop importants et difficiles à mettre en œuvre.

On ne parlait pas encore de flashes mais de « lampes-photos ». L'usage du magnésium, sous forme de poudre ou de rubans, était connu mais pour l'utiliser sous l'eau, il fallait l'enfermer dans une ampoule remplie d'oxygène et l'enflammer à l'aide du courant fourni par des piles électriques. Malheureusement la combustion était irrégulière et l'ampoule, soumise à des variations importantes de pression et à des chocs thermiques, éclatait très souvent. 

Le problème fut résolu par la suite à l'aide d'un système fort ingénieux mais passablement lourd et encombrant. Une barrique en bois de 200 litres permettait d'emmagasiner de l'air enrichi en oxygène.  À sa partie supérieure était assujettie une cloche de verre communicant avec l'intérieur de la barrique par plusieurs trous de gros diamètre. Le fond de la barrique était percé de nombreux petits trous afin de permettre l'entrée de l'eau tout en évitant de trop grandes turbulences et l'ensemble était lesté de 300 kg de plomb.

Dans la cloche se trouvait une lampe à alcool avec à ses côtés une petite boîte contenant de la poudre de magnésium que l'on pouvait souffler sur la flamme grâce à une poire en caoutchouc située à l'extérieur de la barrique et reliée au dispositif par un tube. Arrivé sur les lieux, Louis Boutan équipé de son scaphandre descendait son appareil au fond de l'eau. Lorsque celui-ci était installé, il tirait sur sa corde de sauvetage, le patron de la barque allumait la lampe et laissait descendre la barrique. Après avoir disposé son éclairage, le photographe ouvrait son objectif et pressait sur la poire en caoutchouc pour enflammer le magnésium et provoquer l'éclair nécessaire à la prise de vue. La combustion durait environ 5 s et il ne permettait pas de réaliser de véritables instantanés.

Plus tard, Louis Boutan parvint à réaliser des prises de vue à des profondeurs de l'ordre de 50 m avec des appareils télécommandés par des électroaimants, la lumière étant fournie par des lampes à arc étanches.

=== La suite de sa carrière ===

Après la parution de son livre ''La Photographie sous-marine et les progrès de la photographie'' en 1900, il est nommé en Indochine, puis il donne des cours à son retour en 1906 à la Faculté des Sciences de Bordeaux. En 1915, il met au point avec son frère un appareil de plongée destiné à l'Armée.

On le retrouve plus tard Directeur du Laboratoire de Zoologie d'Arcachon, il termine ensuite sa carrière comme Inspecteur des Pêches à Tigzirt, ville côtière de Kabylie.

En 1925, il devient Président de la Société Zoologique de France.

== Publications ==

* Recherches sur l'anatomie et le développement de la fissurelle. Comparaison de la fissurelle avec les types voisins. Thèse de doctorat, Archives de zoologie expérimentale et générale, 1886.

* La cause principale de l'asymétrie des mollusques gastéropodes. Archives de Zoologie expérimentale et générale, 1899. 

* La Photographie sous-marine et les progrès de la photographie .- Paris, Schleicher, 1900, 327 p. et Paris, Jean-Michel Place, 1987. {{ISBN|2-85893-071-6}}

Il faut ajouter plusieurs manuels pour étudiants et environ 200 communications scientifiques.

== Bibliographie ==

* ROBERT, Vincent .- La photographie sous-marine - Louis Boutan, le précurseur. In : Photo-Ciné-Revue, n° spécial juin 1968, pp. 267-268.

== Lien externe ==
* Elliot Frantz  ; [http://fadedandblurred.com/blog/the-worlds-first-underwater-photographer-louis-boutan/ ''The World’s First Underwater Photographer: Louis Boutan''], avec quelques photographies prises par L Boutan, mis en ligne 2012-09-24, consulté 2014-03-12

{{DEFAULTSORT:Boutan, Louis}}

[[Catégorie:Personnalités de la photographie]]</text>
      <sha1>prrv5gf8ecwndka8z9pa8mcshxold6b</sha1>
    </revision>
  </page>
  <page>
    <title>Livre de cuisine/Tarte aux corn flakes</title>
    <ns>0</ns>
    <id>25792</id>
    <revision>
      <id>684304</id>
      <parentid>449762</parentid>
      <timestamp>2022-08-27T18:42:28Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]] + reformattage + °F -&gt; °C</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1984" xml:space="preserve">{{Livre de cuisine}}
La '''tarte aux « corn flakes »''' est un dessert bien connu dans la région du Saguenay et du lac St-Jean au Québec. C'est le dessert idéal pour les personnes qui souffrent d'intolérance au gluten puisqu'il n'en contient pas.

== Fond de la « tarte » ==

=== Ingrédients ===
# 4 tasses de {{i|céréale}}s corn flakes,
# 3/4 tasse de sucre,
# 1/4 tasse de {{i|beurre}} fondu,
# ½ cuillerée à {{i|thé}} de vanille.

=== Préparation ===
# Préparer un {{Ustensile|moule}} en verre rectangulaire de 9 x 13 pouces.
# Le huiler légèrement.
# Dans un grand {{Ustensile|bol}}, émietter les céréales avec les mains le plus possible; ajouter le sucre et le beurre fondu; bien mélanger.
# Presser cette préparation au fond du moule.
# Cuire au four à [[Thermostat de cuisson|180°C]], pendant 10 minutes et laisser refroidir le fond de tarte.

== Garniture ==

=== Ingrédients ===
* 3 jaunes d’œufs (garder les blancs pour la meringue),
* 2 1/2 tasses de lait (écrémé, 2% ou entier),
* 3/4 de tasse de sucre,
* 3 c. à table de fécule de maïs,
* ½ c. à thé de vanille.

=== Préparation ===
# Dans un {{TechniqueCuisine|bain-marie|Cuire au bain-marie}}, faire chauffer le lait et le sucre.
# Mélanger les jaunes d’œufs avec la fécule de maïs.
# Lorsque le lait est chaud, réchauffer graduellement le mélange de jaunes d’œufs et de fécule avec du lait chaud de manière que les jaunes ne coagulent pas en les versant dans le liquide chaud.
# Laisser cuire jusqu’à épaississement tout en brassant.
# Verser dans la croûte refroidie. Laisser refroidir.

== Meringue ==

=== Ingrédients ===
* 3 blancs d’œufs,
* 2 c. à soupe de sucre.

=== Préparation ===
# {{TechniqueCuisine|Battre les blancs d'œufs en neige}} avec 2 c. à table de sucre.
# Étendre sur la « tarte ».
# Faire dorer la meringue au four à [[Thermostat de cuisson|180°C]] pendant 5 minutes en surveillant attentivement pour qu’elle ne brûle pas.</text>
      <sha1>4m22donfs59t3j6e65ks3dy82oli3fa</sha1>
    </revision>
  </page>
  <page>
    <title>Livre de cuisine/Pompe de Lissonnat</title>
    <ns>0</ns>
    <id>26686</id>
    <revision>
      <id>684275</id>
      <parentid>644955</parentid>
      <timestamp>2022-08-27T18:16:22Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1019" xml:space="preserve">''Attention à ne pas confondre avec la [[Livre de cuisine/Pompe à l'huile|Pompe à l'huile]].''  [[Image:Disambig colour.svg|20px]]
----
La '''pompe de Lissonnat''' est un plat traditionnel préparé à [[w:Saillant (Puy-de-Dôme)|Saillant]].

== Ingrédients ==
* Farine de {{i|seigle}},
* Sucre,
* 4 œufs,
* Fruits secs (pruneaux, abricots, raisins, etc.),
* Lait.

== Préparation ==
# Dans un plat à flans, mettre 6 cuillères de {{i|farine}} de seigle.
# Rajouter 6 cuillères de sucre.
# Délayer dans du {{i|lait}} afin d'obtenir une pâte semi-liquide.
# Casser les 4 œufs et mettre tout leur contenu dans le plat.
# Rajouter enfin les {{i|fruit}}s secs. Il n'y a pas de dosage précis, tout dépend des goûts des futurs consommateurs !
# Faire cuire au four doucement pendant 1 h 30.
# Manger chaud.

== Note ==
De tradition, tout le monde mange dans le même plat.

[[Catégorie:Desserts|Pompe de Lissonnat]]
[[Catégorie:Cuisine auvergnate]]
[[Catégorie:Recettes végétariennes]]
{{Livre de cuisine}}</text>
      <sha1>ox2jdrzwun3ck60uvu60rhyym4gcaqx</sha1>
    </revision>
    <revision>
      <id>684276</id>
      <parentid>684275</parentid>
      <timestamp>2022-08-27T18:17:51Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>/* Ingrédients */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1057" xml:space="preserve">''Attention à ne pas confondre avec la [[Livre de cuisine/Pompe à l'huile|Pompe à l'huile]].''  [[Image:Disambig colour.svg|20px]]
----
La '''pompe de Lissonnat''' est un plat traditionnel préparé à [[w:Saillant (Puy-de-Dôme)|Saillant]].

== Ingrédients ==
* farine de {{i|seigle}},
* {{i|sucre,
* 4 {{i'|œuf|œufs}},
* {{i|fruit sec|fruits secs}} (pruneaux, abricots, raisins, etc.),
* {{i|lait}}.

== Préparation ==
# Dans un plat à flans, mettre 6 cuillères de {{i|farine}} de seigle.
# Rajouter 6 cuillères de sucre.
# Délayer dans du {{i|lait}} afin d'obtenir une pâte semi-liquide.
# Casser les 4 œufs et mettre tout leur contenu dans le plat.
# Rajouter enfin les {{i|fruit}}s secs. Il n'y a pas de dosage précis, tout dépend des goûts des futurs consommateurs !
# Faire cuire au four doucement pendant 1 h 30.
# Manger chaud.

== Note ==
De tradition, tout le monde mange dans le même plat.

[[Catégorie:Desserts|Pompe de Lissonnat]]
[[Catégorie:Cuisine auvergnate]]
[[Catégorie:Recettes végétariennes]]
{{Livre de cuisine}}</text>
      <sha1>fbhl0899gk3lqoe1e7hxaochhsje0nn</sha1>
    </revision>
    <revision>
      <id>684277</id>
      <parentid>684276</parentid>
      <timestamp>2022-08-27T18:17:58Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>/* Ingrédients */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1059" xml:space="preserve">''Attention à ne pas confondre avec la [[Livre de cuisine/Pompe à l'huile|Pompe à l'huile]].''  [[Image:Disambig colour.svg|20px]]
----
La '''pompe de Lissonnat''' est un plat traditionnel préparé à [[w:Saillant (Puy-de-Dôme)|Saillant]].

== Ingrédients ==
* farine de {{i|seigle}},
* {{i|sucre}},
* 4 {{i'|œuf|œufs}},
* {{i|fruit sec|fruits secs}} (pruneaux, abricots, raisins, etc.),
* {{i|lait}}.

== Préparation ==
# Dans un plat à flans, mettre 6 cuillères de {{i|farine}} de seigle.
# Rajouter 6 cuillères de sucre.
# Délayer dans du {{i|lait}} afin d'obtenir une pâte semi-liquide.
# Casser les 4 œufs et mettre tout leur contenu dans le plat.
# Rajouter enfin les {{i|fruit}}s secs. Il n'y a pas de dosage précis, tout dépend des goûts des futurs consommateurs !
# Faire cuire au four doucement pendant 1 h 30.
# Manger chaud.

== Note ==
De tradition, tout le monde mange dans le même plat.

[[Catégorie:Desserts|Pompe de Lissonnat]]
[[Catégorie:Cuisine auvergnate]]
[[Catégorie:Recettes végétariennes]]
{{Livre de cuisine}}</text>
      <sha1>n91ljatzhx5jomtxkaux2zsij1zzmv6</sha1>
    </revision>
  </page>
  <page>
    <title>Projet/Montagne</title>
    <ns>0</ns>
    <id>26767</id>
    <revision>
      <id>684296</id>
      <parentid>672559</parentid>
      <timestamp>2022-08-27T18:30:47Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6259" xml:space="preserve">{{Icône de titre
  |Lien=w:Projet:Montagne
  |Texte=Projet:Montagne sur Wikipédia, l'encyclopédie libre
  |Image=Wikipedia-logo.svg
  |Taille=24
}}
&lt;div style=&quot;text-align: center;&quot;&gt;&lt;div style=&quot;font-size:320%; color:#133A6D&quot; &gt;'''Projet Montagne'''&lt;/div&gt;
Regroupera tout les projets des wikilivres sur la montagne afin de permettre une meilleure facilité de navigation.
&lt;/div&gt;

[[Image:Bernina Range from Diavolezza.jpg|center|700px]]


{{Début des onglets
|Onglet-1=Le portail
|URL-1=Portail:Montagne
|Onglet-2=Le projet
|URL-2=Projet:Montagne
|Onglet-3=Refuge Wikibooks 
|URL-3=Discuter:Projet:Montagne
|Onglet-4=Étagère
|URL-4=Projet:Montagne/Étagère
|Onglet-5=Aide
|URL-5=Projet:Montagne/Aide
|bordure=1px solid #dddddd
|fond onglets=#eeeeee
&lt;!--|fond cadre=#FFFFEE--&gt;
|arrondi=5em
|alignement onglet=center
}}
__NOTOC__
&lt;div style=&quot;text-align: center;&quot;&gt;
Bienvenue sur le '''projet concernant les wikilivres de montagne''' ! 

Si une tempête s'annonce, allez donc boire un verre au [[Discuter:Projet:Montagne|refuge]]... Ce projet a été ouvert dans la perspective de créer des wikilivres sur le sujet de la montagne, de compléter ceux déjà existants et surtout d'assurer la liaison Wikipédia/Wikibooks sur les articles concernés. Les pages de discussion des livres de montagne sont centralisées au [[Discuter:Projet:Montagne|refuge]].
__TOC__
&lt;/div&gt;

== Secourisme et médecine ==
C'est une branche intéressante à exploiter. 

== [[Image:Wikijunior logo world.svg|48px]] Wikijunior {{Fait}}==
Il faudrait créer sur Wikijunior un livre concernant la montagne de manière généraliste: formation des montagnes, les montagnes dans l'histoire, anecdotes, sports pratiqués, etc.
Voir:
*[[Wikijunior]]
*[[Wikijunior:La montagne]]
:Commencé --[[Utilisateur:Savant-fou|Savant-fou]] 10 septembre 2008 à 18:34 (CEST)
:Terminé --[[Utilisateur:Savant-fou|Savant-fou]] 28 septembre 2008 à 11:45 (CEST)
=== Interview ? ===
Il faudrait trouver une ou des personnes qui travaillent en montagne pour essayer de faire une sorte de petite &quot;interview&quot; dans la page [[Wikijunior:La montagne/Métiers]].
:Interview avec des pros en cours. --[[Utilisateur:Savant-fou|Savant-fou]] 13 septembre 2008 à 11:40 (CEST)
== [[Image:Crystal Clear action configure.png|48px]] Modèles ==
Voir [[Projet:Montagne/Ressources|les ressources du projet]].

== Bandeaux de sécurité (obligatoires) ==
N'oubliez pas les bandeaux de sécurité à apposer sur la page principale des wikilivres !
[[Image:Projet_Montagne_Wikibooks.jpg|right]]
Voir [[Projet:Montagne/Aide#Aide#Aide pour la création d'un nouveau Wikilivre sur la montagne#Bandeaux de sécurité (obligatoires)|ici]].

== [[Image:Evolution-tasks.png]] Tâches ==
Quand vous vous occupez d'une tâche, barrez-la (&lt;nowiki&gt;&lt;s&gt; ... &lt;/s&gt;&lt;/nowiki&gt;) et signez à côté (&lt;nowiki&gt;--~~~~&lt;/nowiki&gt;). Ajoutez &lt;nowiki&gt;{{fait}}&lt;/nowiki&gt; quand le wikilivre est terminé.
=== Diverses ===
*Créer les wikilivres présentés dans la section appropriée ci-dessous.
*S'occuper particulièrement du wikilivre de wikijunior sur la montagne.
*Définir les tâches...
*Voir le [[Guide de survie]] à la page [[Guide de survie/Montagne|Montagne]].
=== Liaison Wikipédia/Wikibooks ===
*À l'aide du modèle &lt;nowiki&gt;{{wikilivres|...}}&lt;/nowiki&gt;, créer sur Wikipédia des liens vers les wikilivres correspondants.
*Sur Wikipédia, placer des liens sur les pages de sommets (avec &lt;nowiki&gt;{{Alpinisme_wikibooks|Lien=LIEN|Titre=TITRE_DU_LIEN}}&lt;/nowiki&gt;) vers les pages présentants des courses de Wikibooks.
**Voir la [[w:Modèle:Alpinisme wikibooks|documentation précise de ce modèle si besoin]].
* On pourra éventuellement collaborer avec le [[w:Projet:Montagne|Projet:Montagne]] de Wikipédia.

=== Maintenance des articles ===
* &lt;s&gt;Catégoriser les wikilivres.&lt;/s&gt; --[[Utilisateur:Savant-fou|Savant-fou]] 7 octobre 2008 à 22:43 (CEST)
=== Aide ===
* &lt;s&gt;Remplir l'aide sur la page du projet.&lt;/s&gt; --[[Utilisateur:Savant-fou|Savant-fou]] 10 septembre 2008 à 12:26 (CEST)
=== Projets de wikilivres ===
''Si vous pensez que la création d'un wikilivre est urgente, alors mettez le titre en gras et apposez &lt;nowiki&gt;{{Danger}}&lt;/nowiki&gt; à côté.''
* &lt;s&gt;[[Randonnée dans les Alpes]]&lt;/s&gt; --[[Utilisateur:Savant-fou|Savant-fou]] 9 septembre 2008 à 17:14 (CEST)
* &lt;s&gt;[[L'Alpinisme]]&lt;/s&gt; --[[Utilisateur:Savant-fou|Savant-fou]] 9 septembre 2008 à 17:14 (CEST)
* {{Fait}}&lt;s&gt;'''[[Wikijunior:La montagne]]'''&lt;/s&gt; --[[Utilisateur:Savant-fou|Savant-fou]] 10 septembre 2008 à 18:34 (CEST) --[[Utilisateur:Savant-fou|Savant-fou]] 28 septembre 2008 à 11:46 (CEST)
* &lt;s&gt;'''[[Livre de nœuds]]'''&lt;/s&gt;
* [[Courses dans les Alpes]]
* [[Randonnée dans les Pyrénnées]]
* '''[[Secourisme en montagne]]'''&lt;nowiki&gt;{{Danger}}&lt;/nowiki&gt;
:Commencé --[[Utilisateur:Hérisson|Hérisson]] 22 juillet 2011 (Je propose une simple révision/adaptation des premiers secours/soins vu sur wikipédia)

=== Ressources ===
* Sur la page [[Projet:Montagne/Ressources|Ressources]], faire une liste de toutes les fichiers de commons ayant un rapport avec la montagne. Si un tri n'est pas nécessaire, alors on mettra un lien vers la catégorie.
* Sur la même page, lister des sites de choix sur les sports de montagne. Attention à ne présenter que ceux &quot;dignes d'intérêt&quot;.

== [[Image:Crystal 128 kuser.png|48px]] Participants ==
''Ajoutez votre nom d'utilisateur, la date et (facultatif) sur quoi vous pensez contribuer principalement. Tout le monde est admis !''
* [[Utilisateur:Savant-fou|Savant-fou]] - 10 septembre 2008 à 12:31 (CEST) -- ''Créateur du projet''
* [[Utilisateur:Paranoramak|Paranoramak]] - 19 novembre 2008 à 17:40 (CET) -- ''Wikilivre des randonnées dans les Alpes''
* ...Tous les Wikirédacteurs !
&lt;small&gt;[{{fullurl:Projet:Montagne|action=edit&amp;section=22}} Se rajouter à la liste des participants]&lt;/small&gt;


&lt;div style=&quot;border:1px solid black;background:rgb(00%,800%,800%);text-align:center;padding=0.4ex;&quot;&gt;
'''Voyez également les autres projets de Wikibooks :'''

[[Wikijunior]] - [[Projet:Programmation|Programmation]] - [[Wikilivres:Projet Enseignement du néerlandais|Le Néerlandais]]

[[Image:Jackl wikijunior.png|50px]] [[Image:Desktop computer clipart - Yellow theme.svg|50px]]
&lt;/div&gt;

[[Catégorie:Projets Wikilivres]]</text>
      <sha1>gsi3swfht7ivordt9gzzk4r1iwla82q</sha1>
    </revision>
  </page>
  <page>
    <title>Livre de nœuds</title>
    <ns>0</ns>
    <id>26900</id>
    <revision>
      <id>684259</id>
      <parentid>639671</parentid>
      <timestamp>2022-08-27T18:05:00Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="466" xml:space="preserve">&lt;div style=&quot;text-align: center;&quot;&gt;
{| class=&quot;wikitable&quot; border=&quot;1&quot;
|-
| style=&quot;text-align: center; padding:2em;&quot;|
&lt;div style=&quot;font-size:250%; color:#259; margin: 1em 0;&quot; &gt;'''BIENVENUE''' DANS LE '''LIVRE DE NŒUDS !'''&lt;/div&gt;
En escalade, en nautisme ou juste pour le plaisir...
[[Image:Nœud de chaise.jpg|center|100px]]
[[Livre de nœuds/Accueil|Commencer à lire]]
|}
&lt;/div&gt;

[[Catégorie:Montagne]]
[[Catégorie:Bricolage]]
[[Catégorie:Livre de nœuds (livre)|*]]</text>
      <sha1>d0gfq03ajmni6rbzmm4zx7ju5mzhups</sha1>
    </revision>
  </page>
  <page>
    <title>Pour lire Platon</title>
    <ns>0</ns>
    <id>29731</id>
    <revision>
      <id>684262</id>
      <parentid>674192</parentid>
      <timestamp>2022-08-27T18:06:29Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7290" xml:space="preserve">__NOTOC__

== '''Pour lire Platon '''==
{{version imprimable}}
{{autres projets|commons=Category:Philosophy}}

{|class=wikitable
|[[Image:Plato_Pio-Clemetino_Inv305.jpg|290px]]
|'''&lt;sub&gt;Ce livre propose de fournir au lecteur les connaissances nécessaires à la compréhension des œuvres de Platon. Il s'adresse aux débutants (par exemple, des élèves de terminale, mais également tous ceux qui souhaitent acquérir une culture générale ou découvrir ce philosophe sans avoir de culture philosophique particulière) et aux lecteurs intermédiaires ou avancés, c'est-à-dire à des lecteurs qui ont lu quelques dialogues et qui sont éventuellement familiers de quelques-unes des notions principales de Platon.&lt;/sub&gt;'''


'''''&lt;sub&gt;Il ne s'agit pas de prétendre à une lecture exhaustive d'une œuvre monumentale mais de trouver des fils à tisser pour rendre possible une lecture autonome. Simplifier n'est pas réduire le sens.&lt;/sub&gt;'''''  

'''''&lt;sub&gt;Ni une lecture chronologique, ni thématique, ce sera une lecture en constellation dont le tracé surgira après une promenade dans les textes.&lt;/sub&gt;'''''  

'''''&lt;sub&gt;L'ordre se crée et ne se donne pas immédiatement.&lt;/sub&gt;'''''  

'''''&lt;sub&gt;Voyager au cœur des mythes, des métaphores et des exemples est le parti-pris de ce livre. Platon hérite de toute une tradition qu'il repense. C'est ce travail  que nous présentons ici. Il ne saurait y avoir une lecture linéaire de son œuvre. Cette croyance aboutirait à l'illusion que le temps dans son déroulement améliorerait la réflexion. Ceci n'est qu'un refoulé de la confiance en l'idée de progrès historique. La vérité serait un horizon lointain dont le discours de la raison se rapprocherait sans fin. Platon nous tend des fils et attend notre lecture&lt;/sub&gt;'''&lt;sub&gt;.&lt;/sub&gt;''  
|}

== Table des matières ==

=== '''[[/Platon et les mythes/]]''' ===
* [[Pour lire Platon/Platon et les mythes#Qui est Platon ?|1 Qui est Platon ?]]
* [[Pour lire Platon/Platon et les mythes#Pourquoi Platon a-t-il écrit ?|2 Pourquoi Platon a-t-il écrit ?]]
* [[Pour lire Platon/Platon et les mythes#Qu'a-t-il écrit ?|3 Qu'a-t-il écrit ?]]
* [[Pour lire Platon/Platon et les mythes#Dans quel ordre Platon a-t-il écrit ses dialogues ?|4 Dans quel ordre Platon a-t-il écrit ses dialogues ?]]
* [[Pour lire Platon/Platon et les mythes#Pourquoi Platon a-t-il écrit des dialogues et pas des traités ?|5 Pourquoi Platon a-t-il écrit des dialogues et pas des traités ?]]
* [[Pour lire Platon/Platon et les mythes#Qui sont les personnages des dialogues de Platon ?|6 Qui sont les personnages des dialogues de Platon ?]]
* [[Pour lire Platon/Platon et les mythes#Pourquoi Socrate est-il le personnage principal des dialogues de Platon ?|7 Pourquoi Socrate est-il le personnage principal des dialogues de Platon ?]]
* [[Pour lire Platon/Platon et les mythes#De quoi Platon parle-t-il dans ses dialogues ?|8 De quoi Platon parle-t-il dans ses dialogues ?]]
* [[Pour lire Platon/Platon et les mythes#Les dialogues de Platon forment-ils un système philosophique ?|9 Les dialogues de Platon forment-ils un système philosophique ?]]
* [[Pour lire Platon/Platon et les mythes#Pourquoi lire un auteur qui est mort il y a 24 siècles ?|10 Pourquoi lire un auteur qui est mort il y a 24 siècles ?]]

=== '''[[/Conseils pour la lecture|Conseils pour la lecture]]''' ===
*&lt;small&gt;Quelques conseils élémentaires avant de se lancer&lt;/small&gt;

* [[Pour lire Platon/Conseils pour la lecture#Quelles traductions choisir ?|1 Quelles traductions choisir ?]]
* [[Pour lire Platon/Conseils pour la lecture#Faut-il apprendre le grec pour bien comprendre Platon ?|2 Faut-il apprendre le grec pour bien comprendre Platon ?]]
* [[Pour lire Platon/Conseils pour la lecture#Par quels dialogues commencer ?|3 Par quels dialogues commencer ?]]
* [[Pour lire Platon/Conseils pour la lecture#Comment tirer profit de la lecture des dialogues ?|4 Comment tirer profit de la lecture des dialogues ?]]
* [[Pour lire Platon/Conseils pour la lecture#Quels outils utiliser au cours de la lecture ?|5 Quels outils utiliser au cours de la lecture ?]]
* [[Pour lire Platon/Conseils pour la lecture#Quels livres lire sur Platon ?|6 Quels livres lire sur Platon ?]]

=== '''[[Pour lire Platon/Introduction par les mythes|Introduction par les mythes]]''' ===
*&lt;small&gt;Quelques questions philosophiques posées par les mythes&lt;/small&gt;
** [[Pour lire Platon/Introduction par les mythes#La philosophie|1 La philosophie]]
*** [[Pour lire Platon/Introduction par les mythes#Fille de l'étonnement et de l'arc-en-ciel|1.1 Fille de l'étonnement et de l'arc-en-ciel]]
*** [[Pour lire Platon/Introduction par les mythes#Désirer le vrai ou la question du manque|1.2 Désirer le vrai ou la question du manque]]
***# [[Pour lire Platon/Introduction par les mythes#La définition du Banquet : l'opinion, Aristophane et Diotime|1.2.1 La définition du Banquet : l'opinion, Aristophane et Diotime]]
***# [[Pour lire Platon/Introduction par les mythes#Discours d'Aristophane ou le désir du corps|1.2.2 Discours d'Aristophane ou le désir du corps]]
***# [[Pour lire Platon/Introduction par les mythes#Diotime ou le désir philosophique|1.2.3 Diotime ou le désir philosophique]]
** [[Pour lire Platon/Introduction par les mythes#Socrate parlait, Platon écrit|2 Socrate parlait, Platon écrit]]
** [[Pour lire Platon/Introduction par les mythes#La philosophie et le mythe : puissance de l'imagination pour suppléer à la raison ?|3 La philosophie et le mythe : puissance de l'imagination pour suppléer à la raison ?]]
*** [[Pour lire Platon/Introduction par les mythes#Prenons un exemple à propos de la justice si difficile à élaborer : le Mythe de l'anneau de Gygès|3.1 Prenons un exemple à propos de la justice si difficile à élaborer : le Mythe de l'anneau de Gygès]]
** [[Pour lire Platon/Introduction par les mythes#Quelle est la place du philosophe dans la cité ?|4 Quelle est la place du philosophe dans la cité ?]]
** [[Pour lire Platon/Introduction par les mythes#Une philosophie politique en réponse au Procès|5 Une philosophie politique en réponse au Procès]]
*** [[Pour lire Platon/Introduction par les mythes#Pourquoi obéir aux lois ?|5.1 Pourquoi obéir aux lois ?]]
**** [[Pour lire Platon/Introduction par les mythes#Lecture conseillée : Criton (sur Wikisource)|5.1.1 '''Lecture conseillée''' : ''Criton (sur Wikisource)'']]
** [[Pour lire Platon/Introduction par les mythes#Liste des mythes|6 Liste des mythes]]

=== '''La place des images dans les œuvres''' ===
* Dialogues et théâtre : la mise en scène
* Étude des exemples relatifs à  la méthode
** Le dessin géométrique dans Ménon
** Le début du dialogue avec Ménon
* Les exemples et les métaphores
** Ménon : les abeilles, le taon 
** Hippias Majeur et le beau
** La métaphore médicale
** Le capitaine
** Le tissage
** La technique

===== Analyse =====
[[Fichier:Plato's allegory of the cave.jpg|vignette]]
* L'allégorie de la caverne

* Mythes eschatologiques

===== Conclusion : Le sensible et l'image =====

== Étude de dialogues ==

===[[w:Études_de_quelques_passages_des_dialogues| Lettre VII]]===
===[[s:Pour_lire_Platon/Guide_des_dialogues/Ménon|Ménon]]===
 
[[Catégorie:Philosophie]]
{{AutoCat}}</text>
      <sha1>5kn0dzc9ljespuvhyecxogvr83xkv15</sha1>
    </revision>
  </page>
  <page>
    <title>Grec ancien/Exercices Textes à lire</title>
    <ns>0</ns>
    <id>29913</id>
    <revision>
      <id>684261</id>
      <parentid>639839</parentid>
      <timestamp>2022-08-27T18:05:56Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8607" xml:space="preserve">&lt;noinclude&gt;{{Grec ancien}}&lt;/noinclude&gt;

== Exercice 1 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Lisez le texte en Grec suivant.'''&lt;br&gt;Si vous avez besoin d'aide, consultez la page ''[[Grec ancien/Alphabet|Alphabet]]''.}}
[[Fichier:Beginning Odyssey.svg|left|370px]]
=== Traduction ===
Muse, chante ce héros, illustre par sa prudence, qui longtemps erra sur la terre après avoir détruit la ville sacrée de Troie, qui parcourut de populeuses cités, s'instruisit de leurs mœurs, et fut, sur les mers, en proie aux plus vives souffrances pour sauver ses jours et ramener ses compagnons dans leur patrie. Mais, malgré tous ses efforts, il ne put les y conduire, et ils périrent victimes de leur imprudence : les insensés osèrent se nourrir des troupeaux consacrés au céleste soleil, et ce dieu leur enleva la journée du retour ! Déesse, fille de Jupiter, raconte-nous quelques-unes de ces aventures.
{{droite|Traduit par [[w:|Eugène Bareste]]&lt;br&gt;Début de ''l'Odyssée'' d'Homère}}

== Exercice 2 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Lisez le texte en Grec suivant.'''&lt;br&gt;Si vous avez besoin d'aide, consultez la page ''[[Grec ancien/Alphabet|Alphabet]]''.}}
[[Fichier:Beginning Iliad.svg|left|370px]]
=== Traduction ===
Chante, Déesse, du Pèlèiade Akhilleus la colère désastreuse, qui de maux infinis accabla les Akhaiens, et précipita chez Aidès tant de fortes âmes de héros, livrés eux-mêmes en pâture aux chiens et à tous les oiseaux carnassiers. Et le dessein de Zeus s’accomplissait ainsi, depuis qu’une querelle avait divisé l’Atréide, roi des hommes, et le divin Akhilleus.
{{droite|Traduit par [[w:Leconte de Lisle|Leconte de Lisle]]&lt;br&gt;Extrait de ''l'Iliade'' d'Homère}}

== Exercice 3 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Traduisez les mots suivants en Français.'''&lt;br&gt;Si vous avez besoin d'aide, consultez la page ''[[Grec ancien/Alphabet|Alphabet]]''.}}
#δημοκρατία
#μαθεματος
#μυθος
#λογος
#θερμος
#ἐνθουσιασμός

{{Boîte déroulante|titre=Afficher les réponses|contenu=#Démocratie
#Mathématiques
#Mythe
#Discussion/Discours
#Température/Chaleur
#Enthousiasme
|style=classe CSS}}

== Exercice 4 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Archéologie: déchiffrage d'une stèle Grecque. Réécrivez-la en tenant compte des espaces et des majuscules en début de phrase uniquement. Lisez le texte obtenu.'''&lt;br&gt;Si vous avez besoin d'aide, consultez les pages ''[[Grec ancien/Alphabet|Alphabet]]'' et ''[[Grec ancien/Écriture|Écriture]]''.}}
[[Fichier:Dedication Ptolemy VI Louvre Ma4977.jpg|center|thumb|780px|&lt;div style=&quot;text-align: center;&quot;&gt;Cliquez sur l'image pour l'afficher en grand écran.&lt;br&gt;Dédicace à Ptolémée VI d'Égypte. Calcaire égyptien, milieu du IIe siècle av. J.-C., découvert en 1907 à Horbeit.&lt;br&gt;Pour afficher une version plus propice à la lecture, cliquez [//upload.wikimedia.org/wikipedia/commons/f/f3/Dedication_Ptolemy_VI_Louvre_Ma4977.jpg ici].&lt;/div&gt;]]
{{Boîte déroulante|titre=Afficher les réponses|contenu=
'''&lt;strong&gt;En cours !&lt;/strong&gt;'''
}}

== Exercice 5 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Transcrivez les lettres suivantes en minuscule si elles sont en majuscule et vice-versa.'''&lt;br&gt;Si vous avez besoin d'aide, consultez la page ''[[Grec ancien/Alphabet|Alphabet]]''.}}
{{tab transparent|left|33}}
#Ή
#Ό
#Ύ
#Ώ
#Γ
#Έ
#Κ
#Δ
#Η
#Π
{{tab transparent colonne|33}}
11. Θ&lt;br&gt;
12. ξ&lt;br&gt;
13. ζ&lt;br&gt;
14. Σ&lt;br&gt;
15. φ&lt;br&gt;
16. ά&lt;br&gt;
17. έ&lt;br&gt;
18. β&lt;br&gt;
19. ς ''(où cette lettre est-elle utilisée ?)''&lt;br&gt;
20. σ ''(où cette lettre est-elle utilisée ?)''&lt;br&gt;
{{tab transparent colonne|33}}
21. ι&lt;BR&gt;
22. Μ&lt;br&gt;
23. Ν&lt;br&gt;
{{tab transparent fin}}
{{boîte déroulante|titre=Afficher les réponses|contenu=
#ή
#ό
#ύ
#ώ
#γ
#έ
#κ
#δ
#η
#π
#θ
#Ξ
#Z
#σ ou ς
#Φ
#Ά
#Έ
#B
#Σ ''utilisé en fin de mot''
#Σ ''utilisé au début ou dans un mot''
#Ι
#μ
#ν
}}

== Exercice 6 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Lisez ce texte.'''&lt;br&gt;Si vous avez besoin d'aide, consultez la page ''[[Grec ancien/Alphabet|Alphabet]]''.}}
{| width=&quot;100%&quot; align=&quot;left&quot; border=&quot;0&quot; cellpadding=&quot;1&quot; cellspacing=&quot;1&quot; 
|- valign=&quot;top&quot;
| width=&quot;1%&quot; |
&lt;strong&gt;'''ΤΡΟΦΟΣ'''&lt;/strong&gt;&lt;br&gt;
ἰώ μοί μοι͵ ἰὼ τλήμων. τί δέ σοι παῖδες πατρὸς ἀμπλακίας μετέχουσι; τί τούσδ΄ ἔχθεις; οἴμοι͵ τέκνα͵ μή τι πάθηθ΄ ὡς ὑπεραλγῶ. δεινὰ τυράννων λήματα καί πως ὀλίγ΄ ἀρχόμενοι͵ πολλὰ κρατοῦντες χαλεπῶς ὀργὰς μεταβάλλουσιν. τὸ γὰρ εἰθίσθαι ζῆν ἐπ΄ ἴσοισιν κρεῖσσον· ἐμοὶ γοῦν ἐν μὴ μεγάλοις ὀχυρῶς γ΄ εἴη καταγηράσκειν. τῶν γὰρ μετρίων πρῶτα μὲν εἰπεῖν τοὔνομα νικᾷ͵ χρῆσθαί τε μακρῷ λῷστα βροτοῖσιν· τὰ δ΄ ὑπερβάλλοντ΄ οὐδένα καιρὸν δύναται θνητοῖς· μείζους δ΄ ἄτας͵ ὅταν ὀργισθῇ δαίμων οἴκοις͵ ἀπέδωκεν.
| width=&quot;1%&quot; |
&lt;strong&gt;'''LA NOURRICE'''&lt;/strong&gt;&lt;br&gt;
O mes enfants, vous entendez ce qu'est votre père pour vous ? Qu'il meure, non, car il est mon maître; pourtant sa méchanceté à l'égard de ceux qui l'aiment est bien prouvée.
{{droite|Traduction [[w:Henri Berguin|Henri Berguin]].&lt;br&gt;Extrait de ''Médée'' d'Euripide}}
|}
{{clr}}

== Exercice 7 ==
{{cadre|[[Fichier:Emblem-question.svg|left]]'''Lisez ce texte.'''&lt;br&gt;Si vous avez besoin d'aide, consultez la page ''[[Grec ancien/Alphabet|Alphabet]]''.}}
{| width=&quot;100%&quot; align=&quot;left&quot; border=&quot;0&quot; cellpadding=&quot;1&quot; cellspacing=&quot;1&quot; 
|- valign=&quot;top&quot;
| width=&quot;1%&quot; |
Κατὰ ταῦτά τις ἐννοεύμενος καὶ σκοπεύμενος προειδείη ἂν τὰ πλεῖστα τῶν μελλόντων ἔσεσθαι ἀπὸ τῶν μεταβολέων. Φυλάσσεσθαι δὲ χρὴ μάλιστα τὰς μεταβολὰς τῶν ὡρέων τὰς μεγίστας, καὶ μήτε φάρμακον διδόναι ἑκόντα, μήτε καίειν ὅ τι ἐς κοιλίην, μήτε τάμνειν, πρὶν παρέλθωσιν ἡμέραι δέκα ἢ καὶ πλείονες· μέγισται δέ εἰσιν αἵδε καὶ ἐπικινδυνόταται, ἡλίου τροπαὶ ἀμφότεραι καὶ μᾶλλον αἱ θεριναί· καὶ ἰσημερίαι νομιζόμεναι εἶναι ἀμφότεραι, μᾶλλον δὲ αἱ μετοπωριναί. Δεῖ δὲ καὶ τῶν ἄστρων τὰς ἐπιτολὰς φυλάσσεσθαι, καὶ μάλιστα τοῦ κυνὸς, ἔπειτα ἀρκτούρου, καὶ ἔτι πληϊάδων δύσιν· τά τε γὰρ νοσεύματα μάλιστα ἐν ταύτῃσι τῇσιν ἡμέρῃσι κρίνεται· καὶ τὰ μὲν ἀποφθίνει, τὰ δὲ λήγει, τὰ δὲ ἄλλα πάντα μεθίσταται ἐς ἕτερον εἶδος καὶ ἑτέρην κατάστασιν. Περὶ μὲν τουτέων οὕτως ἔχει.
| width=&quot;1%&quot; |
En réfléchissant, en examinant ainsi, on préviendra la plupart des effets qui doivent résulter des vicissitudes [des saisons]. Mais il faut surtout prendre garde aux grandes vicissitudes, et alors ne pas administrer de purgatifs sans nécessité, ne pas brûler, ne pas inciser la région du ventre, avant que dix jours et même plus ne soient passés. Les plus grandes et les plus dangereuses vicissitudes sont les deux solstices, surtout celui d’été, et ce qu’on regarde comme les deux équinoxes surtout celui d’automne. Il faut également prendre garde au lever des astres, surtout à celui de la Canicule, ensuite à celui d’Arcturus, et au coucher des Pléiades. C’est principalement à ces époques que les maladies éprouvent des crises, que les unes deviennent mortelles, que les autres cessent ou se changent en maladies d’une espèce et d’une constitution différentes ; il en est ainsi de ces choses.
{{droite|Extrait de « ''[[s:Des airs, des eaux et des lieux|Des airs]]'' » d'[[w:Hippocrate|Hippocrate]].&lt;br&gt;Traduit par Ch. V. Daremberg (1844).}}
|}
{{clr}}

{{Icône version PDF|lien=Media:Grec_ancien_exercice_1.pdf}}
{{Exercice grec}}

[[Catégorie:Grec ancien (livre)|Exercices chapitre 1]]</text>
      <sha1>8hrqefdc001pfdtyff0k3pltnvngxwl</sha1>
    </revision>
  </page>
  <page>
    <title>Pour lire Platon/Vocabulaire</title>
    <ns>0</ns>
    <id>29977</id>
    <revision>
      <id>684255</id>
      <parentid>642546</parentid>
      <timestamp>2022-08-27T18:00:03Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25708" xml:space="preserve">{{ébauche}}
&lt;noinclude&gt;{{Pour lire Platon}}&lt;/noinclude&gt;
Cette annexe propose un vocabulaire de Platon. 

Ce vocabulaire s'organise de la manière suivante. Les explications données dans le présent article sont à l'usage des débutants. Elles se présentent sous la forme de définitions qui n'ont pas la prétention d'être complètes mais d'être faciles à retenir tout en donnant les caractéristiques essentielles de ce qui est à expliquer. Les définitions sont suivies d'explications qui les éclairent et les complètent. Les liens présents dans chaque section renverront à des études plus développées, à l'usage des lecteurs plus avancés.

Cette présentation a un parti pris pédagogique. Pour qu'elle puisse être profitable, voici ce que nous conseillons. Un philosophe ne pense pas à partir de rien, mais a besoin bien au contraire d'outils intellectuels. Parmi ces outils, on trouve des notions philosophiques. C'est pourquoi, si ces notions doivent être évidemment comprises, elles doivent être aussi apprises par cœur, de sorte qu'elles puissent servir à une activité de pensée autonome. Pour bien parler et comprendre une langue, il faut passer par des exercices de mémorisation longs et fastidieux ; de même, l'acquisition d'outils intellectuels demande que l'on exerce sa mémoire afin que l'esprit gagne en étendue et en précision dans ses réflexions.

L'intérêt de définitions courtes et simples est de pouvoir garder facilement en mémoire tout ce qu'il faut savoir pour comprendre un auteur. Les quelques éléments qu'elles fournissent doivent permettre de se remémorer l'ensemble des explications données à leur suite. Ainsi, par un exercice scolaire d'apprentissage, accompagné d'exercices de resouvenir plus précis de la signification des notions présentées ici, on pourra commencer à prétendre à une certaine maîtrise intelligente de la pensée de Platon.


== Âme ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
L'âme est ce qui est principe du mouvement et sujet de la pensée.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;

homme
=

&lt;small&gt;Voir : [[Pour lire Platon/Vocabulaire/Amitié|Amitié]]&lt;/small&gt;

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
L’amitié est le désir de fréquenter qui ou ce qui nous rendra meilleur.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
L'amitié est pour les Grecs une forme d'affection réciproque, ce qui inclut les liens familiaux, les liens sociaux, mais aussi la bienveillance à l'égard de l'étranger. Les poètes et les philosophes avaient conçu deux grandes types de théories de l'amitié : l'amitié est l'attirance des semblables ou des contraires.

Platon rompt avec chacune des conceptions énoncées ci-dessus. Tout d'abord, l'amitié peut ne pas être réciproque, comme l'affection pour des animaux, mais aussi pour des réalités non vivantes, comme le savoir, c'est-à-dire la philosophie ; ensuite, l'amitié n'est en particulier ni l'attirance des semblables ni l'attirance des contraires, car, dans ces deux cas, celui qui a de l'amitié serait la mesure de l'objet de son affection ; or, Pour Platon, l'amitié est un désir, donc un désir de ce que l'on a pas et que l'on n'est pas ; enfin, l'amitié est une affection intéressée, car elle est un désir du bien.

&lt;small&gt;&lt;u&gt;Texte&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Dans cet extrait du ''Lysis'', Platon montre le caractère intéressé de l'amitié : l'ami est utile. Cette conception va à l'encontre de la conception populaire, puisque la recherche de l'utilité semble être à l'extrême opposé de l'amitié. Mais, pour ne pas faire de contre-sens, il faut avoir à l'esprit que l'utilité dont parle Socrate n'est pas l'utilité ''matérielle''. L'utilité recherchée dans l'amitié est l'utilité de l'âme, c'est-à-dire le ''bien moral'', et, pour Platon, ce bien repose sur la connaissance. Dès lors, l'ami est celui (ou la réalité) qui peut nous rendre meilleur, parce qu'il nous montre le bien, objet suprême du désir de l'âme. On remarquera que Platon place cette amitié au-dessus des liens naturels de la famille, ce qui s'accorde avec sa volonté d'abolir la famille dans la ''République''.

« — Socrate : Tu vois donc ce qu’il en est, mon cher Lysis, lui dis-je : pour les choses où nous serons passés maîtres, tout le monde s’en rapportera à nous, Grecs et barbares, hommes et femmes, et nous en userons à notre guise, sans que personne y mette obstacle volontairement ; c’est un domaine où nous serons libres, où nous commanderons même aux autres, et ce domaine sera notre bien, puisque nous en tirerons profit. Mais pour les choses dont nous n’aurons pas acquis la connaissance, personne ne nous permettra d’en user à notre fantaisie ; tout le monde au contraire s’y opposera autant qu’il le pourra, et non seulement les étrangers, mais encore notre père et notre mère et ceux qui pourraient nous toucher encore de plus près ; nous serons ici forcés d’obéir à d’autres, et ces choses seront pour nous des choses étrangères, car nous n’en tirerons aucun profit. M’accordes-tu qu’il en est ainsi ?

— Lysis : Je te l’accorde.

— Soc : Mais nous ferons-nous amis avec quelqu’un et quelqu’un nous aimera-t-il par rapport aux choses où nous ne serons d’aucune utilité ?

— Lys : Non, certes, dit-il.

— Soc : Ainsi ton père n’aimera même pas son fils, ni personne n’aimera un homme, par rapport aux choses où il est inutile ?

— Lys : Il ne me semble pas, dit-il.

— Soc : Si donc tu deviens savant, mon enfant, tout le monde t’aimera, tout le monde s’attachera à toi ; car tu seras utile et bon. Sinon, personne ne t’aimera, ni ton père, ni ta mère, ni tes proches. »

== Amour ==

&lt;small&gt;Voir : [[Pour lire Platon/Vocabulaire/Amour|Amour]]&lt;/small&gt;

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
L'amour est un désir pour un objet (être vivant ou réalité), et plus particulièrement un désir d'engendrer, soit des œuvres, soit des descendants.

== Beau ==

&lt;small&gt;Voir : [[Pour lire Platon/Vocabulaire/Beau|Beau]]&lt;/small&gt;

== Bien ==

*[[Pour lire Platon/Vocabulaire/Bien|Bien]]

== Bonheur ==

*[[Pour lire Platon/Vocabulaire/Bonheur|Bonheur]]

== Cause ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Une cause est soit ce par quoi une chose est ce qu'elle est, soit ce dont elle est constituée.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Platon distingue deux types de cause : 

En un sens premier, la cause explique pourquoi une chose est ce qu'elle est : c'est sa raison d'être. En ce sens, une cause est à la fois ce qui donne une qualité à une chose et ce par quoi on peut la connaître. Par exemple, une chose belle est belle du fait qu'elle reçoit cette qualité de la forme du beau : il y a ainsi un rapport de causalité qui explique pourquoi et comment cette chose est qualifiée. Or, cette qualité est une forme (voir cette section) et elle est connue par sa définition, et même s'identifie à elle. Par conséquent, la connaissance de cette définition rend aussi possible la connaissance de ses effets dans les choses sensibles : connaître une cause en ce sens, c'est donc connaître ce qui produit les déterminations du monde sensible, ce qui donne à ce dernier son caractère intelligible.

En un sens secondaire, la cause est ce dont une chose est faite, comme, par exemple, les éléments (feu, eau, etc.) dont elle est composée.

Ces deux types de cause se combinent : ainsi, le fait que Socrate soit assis dans une prison peut être expliqué par la disposition de ses muscles, de son corps, etc. Mais cette explication est manifestement incomplète, puisque la description des éléments qui constituent cette scène n'expliquent pas ce que Socrate fait en prison. C'est donc par la volonté des Athéniens et de Socrate, ainsi que par leur conception de la justice et d'autres formes (le bien et certaines vertus par exemple), que l'on peut comprendre pourquoi ce dernier est dans cette situation. D'une manière plus générale, le monde est constitué d'éléments, mais ce sont les qualités qu'il reçoit des formes qui permettent d'en comprendre l'organisation et la raison d'être.

== Cité ==

*[[Pour lire Platon/Vocabulaire/Cité|Cité]]

== Connaissance ==

:&lt;small&gt;Voir : [[Pour lire Platon/Vocabulaire/Connaissance|Connaissance]]&lt;/small&gt;

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
La connaissance est une activité de l'âme au contact d'un objet qui lui permet de dire ce qu'est cet objet.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
[[File:Platon-Analogie-Ligne.svg|right|200px]]
Au contact d'un objet, l'âme est affectée de différentes manières qui définissent plusieurs manières de parler de cet objet. Ces différentes manières déterminent différentes manières de connaître qui dépendent de la manière d'être de l'objet. Ainsi, chaque sorte de contact de l'âme à un objet (on parlera de mode de connaissance) a un objet qui lui est propre. Ces modes de connaissance sont classés par Platon comme il suit :

Tout d'abord, au ''non-être'', qui ne définit pas à proprement parler un mode de connaissance, correspond dans l'âme l'''ignorance''.

Aux images et illusions correspond la conjecture.

Aux être vivants et aux objets fabriqués correspond la croyance.

Aux notions et aux nombres, correspond la pensée.

Enfin, aux formes correspond l'intellect.

La conjecture et la croyance ont pour objets des choses sensibles, et Platon réunit ces deux modes de connaissance sous le terme d'''opinion''. L'opinion est donc un jugement de l'âme qui porte sur des sensations. Comme l'objet de l'opinion est changeant, celle-ci ne peut justifier sa vérité et sa fausseté.

La pensée et l'intellect ont pour objets des réalités intelligibles, et Platon les désigne tout deux par le nom de ''science''. La pensée correspond aux raisonnements discursifs se fondant sur des hypothèses et elle englobe les sciences particulières, comme les mathématiques. L'intellect est au contraire une intuition de ce qui est, de manière inconditionnelle, et cette intuition est donc la science par excellence, que Platon nomme ''dialectique'', c'est-à-dire la science des formes et de leurs rapports. À cette forme la plus haute de la connaissance (à proprement parler la seule connaissance vraie) correspond l'activité par excellence de l'âme qui est l'activité de l'intellect. Cette activité par excellence est la vertu de l'âme (voir la section ''vertu'').

On a coutume de représenter cette division de la connaissance et de ses objets par une ligne que l'on appelle ''analogie de la ligne''. Le terme ''analogie'' est utilisée car, d'une part, les images des choses sensibles et les choses sensibles sont dans le même rapport que les objets hypothétiques et les formes ; d'autre part, les choses sensibles sont des images des formes.

{| border=&quot;1&quot; cellpadding=&quot;5&quot; cellspacing=&quot;0&quot; align=&quot;center&quot;
|+'''La ligne'''

! colspan=&quot;2&quot; align=&quot;center&quot; |'''Réalités intelligibles'''
! colspan=&quot;2&quot; align=&quot;center&quot; |'''Choses sensibles'''
|-
! colspan=&quot;2&quot; align=&quot;center&quot; |'''Science''' (''épistèmé'')
! colspan=&quot;2&quot; align=&quot;center&quot; |'''Opinion''' (''doxa'')
|-
! align=&quot;center&quot;| '''Formes, principes non-hypothétiques'''
! align=&quot;center&quot;|'''Objets hypothétiques, mathématiques'''
! align=&quot;center&quot;|'''Objets sensibles'''
! align=&quot;center&quot;|'''Ombres et images des objets sensibles'''
|-
! align=&quot;center&quot;|Connaissance rationnelle intuitive
! align=&quot;center&quot;|Connaissance rationnelle discursive
! align=&quot;center&quot;|Croyances, convictions
! align=&quot;center&quot;|Imaginations
|-
|}

== Courage ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Le courage est la connaissance de ce qu'il faut craindre et ne pas craindre.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Le courage est l'une des vertus cardinales (avec la tempérance, la justice et la prudence), et, en tant que vertu, il est une science. Ce statut de science est expliqué dans le ''Lachès''. Si le courage est une fermeté de l'âme qui consiste à tenir bon et à ne pas fuir, cette définition ne tiendrait pas compte des cas où il est courageux de fuir : par exemple, la tactique des Scythes consiste à combattre l'ennemi en fuyant ; résister à certains plaisirs et les fuir peut être également une forme de courage. Si le courage est la fermeté de l'âme, cette définition est contredite par le fait que, dans certains cas, la fermeté est la conséquence de l'ignorance, voire de la folie : il s'agit alors plutôt de témérité, et non de courage. En conséquence, le courage demande l'intelligence de ce à l'égard de quoi il y a courage. Dès lors, c'est la connaissance qui distingue la témérité du courage, et Platon peut donc affirmer que ce dernier est une science.

== Corps ==

:&lt;small&gt;Voir : [[Pour lire Platon/Vocabulaire/Corps|Corps]]&lt;/small&gt;

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Un corps est une partie de la ''khôra'', composé d'éléments (eau, feu, air, terre) et d'une âme.

== Forme ==

:&lt;small&gt;Voir : [[Pour lire Platon/Vocabulaire/Forme|Forme]]&lt;/small&gt;

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Une forme est une réalité immuable et universelle, indépendante de la pensée, et qui donne au monde sensible ses qualités.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Le mot français ''forme'' (ou ''Forme'' : l'usage de la majuscule est devenu une habitude dans les traductions, mais il n'a rien d'obligatoire) traduit les mots grecs ''idea'' et ''eidos'' ; ces mots sont aussi traduits par le mot « idée ». La traduction par « forme » est toutefois moins ambigüe et préférable, car le mot ''idée'' laisse à penser que l'on parle d'un contenu de pensée, d'une représentation ou de quoique ce soit qui se trouverait dans l'esprit, ce qu'une forme n'est pas. Enfin, certains commentateurs estiment que ''eidos'' et ''idea'' sont deux notions distinctes, bien que liées. Nous en dirons un mot plus loin.

La théorie des formes est une théorie qui vise à répondre aux questions de savoir ce qui est (on parle alors d'ontologie), quelles sont les normes vraies (éthique ou morale) et ce que c'est que savoir (épistémologie). Le fait qu'il n'y ait pour Platon qu'une théorie pour fonder tous ces domaines permet à celle-ci d'être économique, c'est-à-dire d'éviter de multiplier les hypothèses.

Nous développerons cette explication autour de deux questions : qu'est-ce qu'une forme considérée en elle-même ? quelle est la nature du lien entre forme et choses sensibles ?

Une forme est une réalité, et, bien plus, elle est la réalité même, ou la réalité vraie, par opposition aux choses sensibles, qui n'ont de réalité qu'autant qu'elles ont un certain rapport avec une forme.

Une forme est immuable, c'est-à-dire qu'elle est stable et éternelle. Encore une fois, cette caractéristique s'oppose aux choses sensibles, changeantes et éphémères.

Une forme est universelle, c'est-à-dire qu'il y a de la ressemblance entre les choses sensibles parce que chaque qualité présente dans plusieurs choses est déterminée par une seule et unique forme.

En tant que réalité vraie, immuable et universelle, une forme est toujours indépendante de la pensée : elle peut être l'objet d'un savoir, mais elle existe de toute nécessité en dehors de nous, sans quoi elle ne serait que subjective, c'est-à-dire relative à un sujet, et donc changeante, particulière et dépendante de nos opinions. On ne saurait donc qualifier la pensée de Platon d'idéalisme, puisque les formes sont des réalités objectives indépendantes de la pensée.

Une forme détermine des choses sensibles, c'est-à-dire que, si une chose est belle, c'est par la forme du Beau qui est présente d'une certain façon dans le sensible, ou qui s'ajoute aux choses pour les déterminer. Cette conception du lien entre forme et choses sensibles introduit un rapport de causalité et de ressemblance appelé ''participation''. La participation d'une chose sensible à une forme signifie que la chose sensible reçoit une qualité d'une forme : cette dernière est donc la cause de la présence de la qualité dans la chose et cette présence rend le sensible ressemblant à la forme. Ce problème est abordé plus en détails dans la section ''Participation''.

Les qualités déterminées dans le sensible par les formes peuvent-être morales (beau, bien), définir un vivant (homme, cheval) ou être de nature mathématique (grandeur).

Nous avons fait allusion à une possible distinction entre les mots grecs ''eidos'' et ''idea''. Cette interprétation est la suivante : l’''eidos'' (qu'on traduira par forme) est l'aspect de l’''idea'' (traduit par idée) telle qu'on la saisit dans les choses sensibles ; quand je vois une chose belle, je saisis l'idée du Beau dans une chose sensible. L’''idea'' est l'idée proprement dite, en tant qu'on la saisit par l'intellect. Autrement dit, dans cette interprétation, la forme est une manifestation de l'idée qui se présente donc à même les choses sensibles. Cette interprétation permet de souligner un point de doctrine, parfois négligé, à savoir que Platon ''ne divise pas'' le monde en deux : il n'y a pas d'un côté une réalité sensible et de l'autre une réalité constituée par les formes. Si les formes sont la réalité vraie, il ne peut en effet y avoir une deuxième réalité : le monde sensible existe en tant qu'il manifeste les idées. Il y a donc, pour Platon, un seul et même monde.

Le fait qu'il y ait un seul et même monde permet d'éviter certaines objections que Platon énonce dans le ''Parménide''. Par exemple, s'il y a deux mondes séparés, le sensible et l'intelligible, comment peut-on connaître le second à partir du premier, étant donné que nous vivons dans le monde sensible et que l'intelligible est une autre forme de réalité ? La réponse de Platon est que ce qu'il y a dans le sensible, c'est l'intelligible. Toutefois, cela n'élucide pas complètement le rapport de causalité entre la forme et les choses qu'elle qualifie. Pour l'expliquer, Platon introduit un moyen terme, l'âme, car celle-ci est à la fois le principe du mouvement et le sujet de la pensée.


La première chose que l'on peut remarquer, à propos de cette théorie, est sans doute que la signification du mot ''forme'' ne nous donne pas de manière très claire une idée de ce qu'est une réalité de ce genre. Platon n'en a de fait pas donné de définition, mais présente sa théorie comme une hypothèse qu'il construit pour tenter de répondre à des problèmes éthiques, ontologiques et épistémologiques. C'est en la considérant comme telle que l'on en aperçoit l'intérêt. Tout d'abord, l'immuabilité garantit la stabilité de la connaissance, alors que le monde sensible, qui est un flux perpétuel, ne nous permet que de former des opinions, dont rien ne nous dit de manière assurée qu'elles puissent être vraies ou fausses. Ensuite, l'universalité permet de rassembler sous un seul terme les ressemblances que présentent les choses. Sur ces bases, il devient possible de produire un discours vrai, dans la mesure où ce discours traduit la connaissance par l'âme, et, plus précisément, par l'intellect, de ces réalités que l'on appelle de ce fait des ''réalités intelligibles''. La théorie des formes, comme ontologie (c'est-à-dire répondant à la question de savoir ce qui est) permet donc de définir le savoir et d'expliquer comment nous connaissons, c'est-à-dire qu'elle constitue également une épistémologie : la connaissance naît en effet du contact de l'âme avec la réalité intelligible qu'est la forme. L'aspect affectif de cette connaissance est l'''amour'' (voir cette section).

Enfin, pour ce qui regarde la morale, l'existence d'une forme telle que le bien présente de manière évidente un caractère normatif : s'il y a de telles formes immuables et éternelles, elles sont aussi des normes, opposées à la tradition et au conventionnalisme, et elles doivent gouverner les conduites humaines individuelles et collectives. Cette fondation éthique est également politique, puisque la justice d'une cité dépend de la forme du juste. Mais puisqu'il faut connaître cette forme pour être juste et pour pouvoir gouverner une cité selon la justice, alors ce sont ceux dont l'âme est parvenue à la contemplation des réalités intelligibles, c'est-à-dire les philosophes, qui doivent gouverner.


La théorie des formes a été critiquée dès le vivant de Platon. Ce dernier en a rendu compte dans le ''Parménide'', et Aristote a lui aussi exposé des objections selon lesquelles cette théorie pouvait être jugée inutile. Parmi les philosophes contemporains, on peut remarquer un autre genre de critiques, qui soutient que l'hypothèse d'un monde intelligible est une création qui prend sa source dans la haine du monde sensible. Cette dernière critique, de nature psychologique, a été développée par Nietzsche. Il nous semble que les critiques de nature épistémologique et ontologique, exposées tant par Platon que par Aristote, rendent mieux compte de la démarche intellectuelle que supposent les formes : il s'agit avant tout de trouver des solutions à des problèmes philosophiques. En ce sens, la critique de Nietzsche paraît surtout porter contre l'usage dogmatique du platonisme, que l'on trouve par exemple, dans le christianisme, usage qui en ferait une justification d'un ordre moral fermé à toute recherche intellectuelle. C'est pourquoi cette critique ne nous semble pas rendre compte de tous les aspects de la pensée de Platon.

== Justice ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
La justice est l'harmonie des parties d'une cité et d'une âme, lorsque toutes ces parties réalisent les fonctions qui leur revient de réaliser.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
La justice est l'une des vertus cardinales (avec la tempérance, le courage et la prudence). Sa spécificité, par rapport aux autres vertus, est qu'elle n'est pas une activité de l'une des parties de l'âme, mais est l'état d'une âme ou, dans le domaine politique, d'une cité, dont les parties réalisent leur fonction propre.

== Monde ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Le monde est l'ensemble organisé des choses sensibles.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
En tant qu'il est l'ensemble des choses sensibles, le monde est composé des éléments géométriques que sont le feu, l'air, l'eau et la terre. La combinaison de ces éléments déterminent au sein du monde les phénomènes de croissance et de décroissance, de génération et de corruption, c'est-à-dire tous les mouvements que l'on peut désigner par le terme général de devenir.

En tant qu'il est organisé, le monde est le produit d'une intention créatrice : le démiurge, divinité fictive hors du monde, introduit en effet dans la ''khôra'' un ordre mathématique entre les éléments, en prenant modèle sur les formes intelligibles, et crée une âme, principe d'ordre et de mouvement, qui maintiendra le monde dans son cours. Le monde a donc un corps et une âme, ce qui en fait un être vivant.

== Sagesse ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
La sagesse consiste à placer la pensée au principe de ses actions.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;

== Tempérance ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
Le tempérance est la maîtrise des plaisirs.

&lt;small&gt;&lt;u&gt;Explications&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
La tempérance est l'une des vertus cardinales (avec le courage, la justice et la prudence), et, en tant que vertu, elle est une science, ce qui suppose l'activité de la pensée. Cette science porte sur les plaisirs, et, plus exactement, sur la capacité de discerner les plaisirs nécessaires des plaisirs secondaires ou excessifs. De ce fait, comme nous le verrons plus en détails dans la section sur le plaisir, la tempérance n'est pas tant une contrainte ou une ascèse, qu'une conduite qui consiste à bien jouir. Celui qui agit droitement ne se prive donc pas de plaisir, mais choisit au contraire des plaisirs qui lui seront bénéfiques. Par conséquent, Platon ne refuse absolument pas les plaisirs des sens en général, tels que les plaisirs de la table, les rapports sexuels ou les spectacles ; néanmoins, le seul plaisir véritable, le plus haut et le plus excellent, demeure celui de l'âme au contact des réalités intelligibles et, en premier lieu, au contact du bien.

== Vertu ==

&lt;small&gt;&lt;u&gt;Définition&lt;/u&gt;&lt;/small&gt;&lt;br/&gt;
La vertu est l'excellence dans la fonction propre.

== À venir ==

*[[Pour lire Platon/Vocabulaire/Démiurge|Démiurge]]
*[[Pour lire Platon/Vocabulaire/Devenir|Devenir]]
*[[Pour lire Platon/Vocabulaire/Dialectique|Dialectique]]
*[[Pour lire Platon/Vocabulaire/Dieu|Dieu]]
*[[Pour lire Platon/Vocabulaire/Loi|Loi]]
*[[Pour lire Platon/Vocabulaire/Monde|Monde]]
*[[Pour lire Platon/Vocabulaire/Mythe|Mythe]]
*[[Pour lire Platon/Vocabulaire/Nature|Nature]]
*[[Pour lire Platon/Vocabulaire/Nécessité|Nécessité]]
*[[Pour lire Platon/Vocabulaire/Opinion|Opinion]]
*[[Pour lire Platon/Vocabulaire/Paradigme|Paradigme]]
*[[Pour lire Platon/Vocabulaire/Participation|Participation]]
*[[Pour lire Platon/Vocabulaire/Pensée|Pensée]]
*[[Pour lire Platon/Vocabulaire/Philosophie|Philosophie]]
*[[Pour lire Platon/Vocabulaire/Réfutation|Réfutation]]
*[[Pour lire Platon/Vocabulaire/Réminiscence|Réminiscence]]
*[[Pour lire Platon/Vocabulaire/Savoir|Savoir]]
*[[Pour lire Platon/Vocabulaire/Sensation|Sensation]]
*[[Pour lire Platon/Vocabulaire/Technique|Technique]]
*[[Pour lire Platon/Vocabulaire/Vérité|Vérité]]
*[[Pour lire Platon/Vocabulaire/Vivant|Vivant]]

[[Catégorie:Vocabulaire philosophique]]</text>
      <sha1>rh1nh5ohbl5or51smoip4g1xzb18iuh</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Afficher un texte</title>
    <ns>0</ns>
    <id>30590</id>
    <revision>
      <id>684291</id>
      <parentid>672680</parentid>
      <timestamp>2022-08-27T18:28:28Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="9374" xml:space="preserve">&lt;noinclude&gt;{{Programmation Python}}&lt;/noinclude&gt;

Ce chapitre détaille les différentes manières d'afficher un texte en console, par exemple pour générer des {{wt|log}}s. Les interfaces graphiques plus élaborées seront traitées avec des bibliothèques.

== print() ==
La fonction ''print'' sert à afficher des données sur la sortie standard, qui est l’écran. Exemple :
{{Cadre code|''' fonction ''print'''''
|&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; print('Hello World!')
Hello World!
&lt;/syntaxhighlight&gt;
}}

La fonction help de l'interpréteur interactif donne la syntaxe des arguments de la fonction &lt;code&gt;print&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
&lt;/syntaxhighlight&gt;

=== print formaté ===
Il est possible de changer une partie du texte en y incorporant des ''marqueurs de conversion'' précédés de l'opérateur &quot;%&quot;. Il s'agit alors d'un &quot;print formaté&quot; (comme avec {{w|printf}} dans d'autres langages). 

Les paramètres placés entre parenthèses à droite de la chaîne à afficher seront insérés dedans, en lieu et place des marqueurs. Cette technique a l'avantage de convertir automatiquement les variables pour qu'elles s'inscrivent dans le texte et qu'elles s'affichent.

Parmi les marqueurs disponibles&lt;ref&gt;https://docs.python.org/2.4/lib/typesseq-strings.html&lt;/ref&gt;, on trouve :
* &lt;code&gt;%s&lt;/code&gt; représente un paramètre de type &quot;string&quot; (texte).
* &lt;code&gt;%d&lt;/code&gt; un &quot;digit&quot; (nombre entier).
* &lt;code&gt;%f&lt;/code&gt; un &quot;floating&quot; ({{wt|flottant}} : nombre réel).

Exemple :
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; int1, int2 = 1, 2

&gt;&gt;&gt; print(u&quot;le résultat de &quot; + str(int1) + ' + ' + str(int2) + &quot; est &quot; + str(int1 + int2))
  le résultat de 1 + 2 est 3

&gt;&gt;&gt; print(u&quot;le résultat de&quot;, int1 , ' + ', int2, &quot; est &quot;, int1 + int2)
  le résultat de 1 + 2 est 3

&gt;&gt;&gt; print(u&quot;et le résultat de %s + %d est %f&quot; % (int1, int2, int1 + int2))
  et le résultat de 1 + 2 est 3.000000
&lt;/syntaxhighlight&gt;

Depuis la 3.6, On peut aussi format de cette manière :
* &lt;code&gt; f&quot;{variable1} blabla {variable2} etc.&quot;&lt;/code&gt;

Donc en reprenant l'exemple au-dessus :
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; int1, int2 = 1, 2

&gt;&gt;&gt; print(f&quot;et le résultat de {int1} + {int2} est {int1 + int2}&quot;)
  et le résultat de 1 + 2 est 3
&lt;/syntaxhighlight&gt;

Cela équivaut à utiliser la méthode &lt;code&gt;format&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; a, b = 1, 2

&gt;&gt;&gt; # Paramètres nommés
&gt;&gt;&gt; print(&quot;et le résultat de {int1} + {int2} est {int1 + int2}&quot;.format(int1=a, int2=b))
  et le résultat de 1 + 2 est 3

&gt;&gt;&gt; # Paramètres ordinaux (il n'est pas possible de mettre une expression, il faut passer le résultat)
&gt;&gt;&gt; print(&quot;et le résultat de {0} + {1} est {2}&quot;.format(int1,int2,int1+int2))
  et le résultat de 1 + 2 est 3
&lt;/syntaxhighlight&gt;

== &lt;code&gt;input()&lt;/code&gt; ==
la fonction &lt;code&gt;input()&lt;/code&gt; fait comme la fonction &lt;code&gt;print()&lt;/code&gt;, mais stoppe le programme en attente que l'utilisateur presse &quot;entrée&quot;. Son résultat sera de type 'string' (chaîne de caractère, texte).

Ici le contenu de ce que l'utilisateur a tapé avant de valider sera stocké dans la variable nommée variable.
&lt;syntaxhighlight lang=&quot;python3&quot;&gt;
&gt;&gt;&gt; variable = input('Quel est votre nom ? ')
Quel est votre nom ? Pierre Henry FAGAN
&gt;&gt;&gt; type(variable)
&lt;class 'str'&gt;
&gt;&gt;&gt; print('Bonjour ' + variable)
Bonjour Pierre Henry FAGAN

&lt;/syntaxhighlight&gt;

== &lt;code&gt;raw_input()&lt;/code&gt; ==
&lt;code&gt;raw_input()&lt;/code&gt; fait comme &lt;code&gt;input()&lt;/code&gt;, mais renvoie toujours une chaîne de caractère. Elle ne plante pas si le texte est vide.

{{attention|À partir de Python 3.1, la fonction &quot;raw_input()&quot; n'existe plus, et la fonction input() la remplace et renvoie systématiquement une chaîne de caractères.|largeur=petite|clear=left}}

== Afficher des caractères spéciaux ==
Normalement, les symboles ne faisant pas partie du code {{w|ASCII}} sont traités comme les autres. Ex :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print('à â ç é è ê ë ï ô ù ÿ')
&lt;/syntaxhighlight&gt;
&lt;pre&gt;à â ç é è ê ë ï ô ù ÿ&lt;/pre&gt;

Toutefois selon l'encodage, il peut être nécessaire de les convertir en [[À la découverte d'Unicode|Unicode]] en plaçant un &quot;u&quot; avant :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(u'à â ç é è ê ë ï ô ù ÿ')
&lt;/syntaxhighlight&gt;

Pour les retours à la ligne, utiliser &quot;\n&quot;.

== Antislash ==
Les caractères affichés par les fonctions précédentes doivent être encadrés par des apostrophes ou des guillemets, mais que se passe-t-il s'ils contiennent eux-mêmes ces symboles ?

Testons la fonction ''print '' :
{{Cadre code
|''' ce qui marche : '''
|&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; print(&quot;ça marche aussi&quot;)
ça marche aussi
&gt;&gt;&gt; print('et ça ? &quot;ça marche&quot; ou pas')
et ça ? &quot;ça marche&quot; ou pas
&gt;&gt;&gt; print(&quot;et on 'essaye' l'inverse&quot;)
et on 'essaye' l'inverse
&lt;/syntaxhighlight&gt;}}

{{Cadre code
|''' ce qui ne marche pas : '''
|&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; print('un simple guillemet ' encadré par du simple quote ')
[message d'erreur]
&gt;&gt;&gt; print(&quot; pareil pour le &quot; double &quot;)
[message d'erreur]
&gt;&gt;&gt; print(&quot;double &quot; deux &quot; fois dans double&quot;)
[message d'erreur]
&lt;/syntaxhighlight&gt;}}

En Python, le simple quote peut encadrer le double, et le double peut encadrer le simple, car la chaîne commence au premier guillemet et finit au même guillemet.


Pour s'affranchir de ces limitations, on utilise un {{wt|caractère d'échappement}}, qui est, en Python, l'antislash (« \ »). Il permet quelques subtilités complémentaires :

* En premier lieu, il permet d'écrire sur plusieurs lignes n'importe quel type de commande. Pratique pour éviter de dépasser les 120 caractères pouvant nécessiter l'utilisation d'un ascenseur latéral pour être lus.

* À l'intérieur d'une chaîne de caractères, l’''antislash'' permet d'insérer un certain nombre de codes spéciaux (sauts à la ligne, apostrophes, guillemets, etc.). Exemples :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; print('une chaîne avec des \' guillemets \' simples dans des simples, c\'est protégé ')
une chaîne avec des ' guillemets ' simples dans des simples, c'est protégé

&gt;&gt;&gt; txt3 = '&quot;N\'est-ce pas ?&quot; répondit-elle.'
&gt;&gt;&gt; print(txt3)
&quot;N'est-ce pas ?&quot; répondit-elle.

&gt;&gt;&gt; Salut = &quot;Ceci est une chaîne plutôt longue\n contenant plusieurs lignes \
... de texte (Ceci fonctionne\n de la même façon en C/C++.\n\
...     Notez que les blancs en début\n de ligne sont significatifs.\n&quot;
&gt;&gt;&gt; print(Salut)
Ceci est une chaîne plutôt longue
 contenant plusieurs lignes de texte (Ceci fonctionne
 de la même façon en C/C++.
    Notez que les blancs en début
 de ligne sont significatifs.
&lt;/syntaxhighlight&gt;

On remarque que la séquence &lt;code&gt;\'&lt;/code&gt; permet d'insérer une apostrophe dans une chaîne délimitée par des apostrophes, et &lt;code&gt;\&quot;&lt;/code&gt; par des guillemets. De même, &quot;\\&quot; affiche &quot;\&quot;.

D'autres caractères peuvent aussi être introduits par antislash :
* Retour chariot : \n
* Tabulation : \t

== Triple quotes ==
Si le nombre d’antislash nuit à la lisibilité du code, on peut délimiter la chaîne à l'aide de ''triples guillemets'' ou de ''triples apostrophes'' :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; a1 = &quot;&quot;&quot;
... Usage: trucmuche[OPTIONS]
... { -h
...   -H hôte
... }&quot;&quot;&quot;

&gt;&gt;&gt; print(a1)

Usage: trucmuche[OPTIONS]
{ -h
  -H hôte
}
&lt;/syntaxhighlight&gt;

== Commentaires ==

Tout ce qui suit un dièse (''#'') jusqu'à un retour à la ligne est un commentaire : ce n'est pas pris en compte par l'interpréteur. Mais cette règle ne s'applique pas lorsque le dièse est positionné dans une chaîne de caractères (entre quotes).

Le but reste de produire du code compréhensible sans commentaire, mais ce texte affiché uniquement dans le code source, peut servir à expliquer à celui qui relit le code (y compris soi-même), les subtilités les moins évidentes de celui-ci.

{{Exemple|Exemple 1|On notera que la fonction ''print'' affiche son argument.|
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
# Toute cette première ligne est un commentaire.
print(&quot;Bonjour le monde&quot;) # Ceci est également un commentaire
print(&quot;Bonjour&quot;); print(&quot;Le monde&quot;); # Ceci est une ligne comportant
# plusieurs instructions
print(&quot;Cette ligne ne contient pas de #commentaire&quot;)
&lt;/syntaxhighlight&gt;
}}

=== Commentaires de bloc ===
Les commentaires de bloc (''block comments'' en anglais) permettent de commenter plusieurs lignes. En Python, ils sont assurés par des triples apostrophes ou guillemets :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print('début')
'''
Le paragraphe suivant est commenté
sur plusieurs lignes
'''
print('fin')
&lt;/syntaxhighlight&gt;

== Couleurs ==
Il est possible d'écrire en couleurs dans le terminal en précisant leurs codes&lt;ref&gt;https://i.stack.imgur.com/6otvY.png&lt;/ref&gt;. Exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print('\x1b[6;31;40m' + ' Texte rouge ' + '\x1b[0m')
print('\x1b[6;30;42m' + ' Fond vert ' + '\x1b[0m')
&lt;/syntaxhighlight&gt;

== Références ==
{{Références}}</text>
      <sha1>2waf65wu4xufhltjtjxs8fh3q3q0ho3</sha1>
    </revision>
  </page>
  <page>
    <title>Analyse microbiologique des aliments/Plan à trois classes</title>
    <ns>0</ns>
    <id>30976</id>
    <revision>
      <id>684317</id>
      <parentid>450496</parentid>
      <timestamp>2022-08-27T18:53:39Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="963" xml:space="preserve">{{Analyse microbiologique des aliments}}
[[Image:Plan a trois classes.JPG|left|400px]]

Contrairement au plan à deux classes , le plan à trois classes permet de faire des nuances. La norme en vigueur est définie (ici la lettre m). 
* si les résultats de vos test sont &lt; à m , le produit est dit satisfaisant.
* si les résultats de vos test sont compris entre m et M' le produit est dit acceptable
* si les résultats de vos test sont &gt; M' le produit est dit non satisfaisant
* si les résultats de vos test sont &gt; &lt;nowiki&gt;M''&lt;/nowiki&gt; le produit est dit corrompus

 Plan à trois classe : N=norme
* si les résultats sont inférieurs à N : produit satisfaisant
* si les résultats sont compris entre N et 10N : produit acceptable
* si les résultats sont compris entre 10N et 1000N : produit non satisfaisant
* si les résultats sont supérieurs à 1000N : produit corrompu

[[Catégorie:Analyse microbiologique des aliments (livre)|Plan à trois classes]]</text>
      <sha1>m277w3ojt61f4n1wg8304owl6xarpuo</sha1>
    </revision>
  </page>
  <page>
    <title>Du bon usage d'un traitement de texte/Annexes/Code de champ EQ</title>
    <ns>0</ns>
    <id>31390</id>
    <revision>
      <id>684257</id>
      <parentid>480300</parentid>
      <timestamp>2022-08-27T18:01:07Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="9011" xml:space="preserve">Le '''champ EQ''' de Microsoft Office Word permet d'écrire des équations (voir ''[[../../Inclusion d'autres objets|Inclusion d'autres objets]]''). Il est d'un usage peu pratique et limité, et n'est présenté ici qu'à titre d'information. Il peut servir si l'éditeur d'équation n'est pas installé.

Ce champ ne touche pas à la fonte, il ne change que la composition (position du texte par rapport à la page et à la la ligne d'écriture).

== Insérer et modifier un champ de code ==

Raccourcis clavier :
* insérer : {{touche|CTRL}}+{{touche|F9}} ;
* afficher le résultat/modifier le champ : {{touche|MAJ}}+{{touche|F9}}.
Avec les menus :
* insérer : menu '''Insertion | Champ…''', puis, dans le menu '''Catégories''', la catégorie '''Équations et formules''', et dans la liste '''Noms des champs''', on sélectionne '''Eq (Eq)''' ;
* modifier : clic droit, et sélectionner '''Modification du champ…''' dans le menu contextuel.

== Syntaxe générale ==

Les fonctions sont de la forme barre de fraction inversé + code de 1 ou 2 lettres. Le texte sur lequel elles s'appliquent est mis entre parenthèses ; si elles s'appliquent sur plusieurs portions de texte, on sépare ces portions par un point virgule. Par exemple
: &lt;code&gt; {{pointillés|{}} EQ \f{{vert|(}}-b+\r{{rouge|(}}a{{rouge|)}}{{vert|;}}4 {{vert|)}}{{pointillés|} }}&lt;/span&gt;&lt;/code&gt;
: pour obtenir
: &lt;math&gt;\frac{-b+\sqrt{a}}{4}&lt;/math&gt;
: avec
:* la fonction &lt;code&gt;\f(…;…)&lt;/code&gt; qui permet d'obtenir une fraction, et
:* la fonction &lt;code&gt;\r(…)&lt;/code&gt; qui permet d'avoir la racine carrée.
Si une fonction des options, celles-ci sont mise après la fonction et avant les parenthèses, par exemple &lt;code&gt;\x\to(…)&lt;/code&gt; (fonction &lt;code&gt;\x&lt;/code&gt;, option &lt;code&gt;\to&lt;/code&gt;).

Si une option a un paramètre chiffré, on l'accole à l'option, par exemple &lt;code&gt;\a\co3(…)&lt;/code&gt; (fonction &lt;code&gt;\a&lt;/code&gt;, option &lt;code&gt;\co&lt;/code&gt; avec comme paramètre &lt;code&gt;3&lt;/code&gt;).


== Caractères spéciaux ==

Les virgule, parenthèse ouvrante et barre de fraction inversée sont des caractères réservés. Pour les afficher, il faut les faire précéder d'une barre de fraction inversée : &lt;code&gt;\,&lt;/code&gt;, &lt;code&gt;\(&lt;/code&gt;, &lt;code&gt;\\&lt;/code&gt;.

On peut insérer les caractères spéciaux de manière classique (menu '''Insertion | Caractères spéciaux…''' ou bouton graphique {{bouton|Ω}}).

On peut aussi créer des caractères par superposition de deux caractères ''(overstrike)'', avec le code &lt;code&gt;\o(''a'',''b'')&lt;/code&gt;, par exemple
: &lt;code&gt;{{pointillés|{}} EQ \o(O,/) {{pointillés|} }}&lt;/code&gt;
: donne approximativement
: ∅.
Par défauts, les caractères sont alignés par rapport à leur milieu (option correspondante : &lt;code&gt;\ac&lt;/code&gt;). On peut aussi les aligner par rapport à la gauche (&lt;code&gt;\al&lt;/code&gt;) ou à la droite (&lt;code&gt;\ar&lt;/code&gt;), par exemple
: &lt;code&gt;{{pointillés|{}} EQ \o \al(O,/) {{pointillés|} }}&lt;/code&gt;.

== Quatre opérations ==

Les signes &lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt; et &lt;code&gt;/&lt;/code&gt; s'utilisent normalement. Il n'existe pas de code pour avoir l'obèle &lt;code&gt;÷&lt;/code&gt;, le croix de multiplication &lt;code&gt;×&lt;/code&gt; ou le point de multiplication (centré) &lt;code&gt;⋅&lt;/code&gt;, mais on peut insérer les caractères spéciaux correspondant dans le champ.

Une fraction se note &lt;code&gt;\f(''dividende'';''diviseur'')&lt;/code&gt;.

; Exemple
: &lt;code&gt;{{pointillés|{}} EQ \f(a+b;2) {{pointillés|} }}&lt;/code&gt;
: donne
: &lt;math&gt;\frac{a+b}{2}&lt;/math&gt;.

== Opérations classiques ==

Pour élever à une puissance, on utilise &lt;code&gt;\s(…)&lt;/code&gt; (supérieur), par exemple
: &lt;code&gt;{{pointillés|{}} EQ x\s(2) {{pointillés|} }}&lt;/code&gt;
: donne
: x&lt;sup&gt;2&lt;/sup&gt;.
Le caractère mis en supérieur est de la même taille. On peut mettre le caractère plus haut en précisant le nombre de points avec l'option &lt;code&gt;\up&lt;/code&gt; ({{unité|2|pt}} par défaut), par exemple &lt;code&gt;{{pointillés|{}} EQ x\s\up5(2) {{pointillés|} }}&lt;/code&gt; pour élever le caractère de 5 points.

On peut aussi utiliser la mise en supérieur (exposant) classique, qui crée un caractère plus petit :
* combinaison de touches {{touche|CTRL}}+{{touche|MAJ}}+{{touche|{{=}}}} ;
* bouton graphique {{bouton|''x''&lt;sup&gt;2&lt;/sup&gt;}} ;
* menu '''Format | Police''', option '''Exposant'''.

La racine carrée s'obtiennent avec &lt;code&gt;\r(…)&lt;/code&gt; (radical). La racine nième s'obtient avec &lt;code&gt;\r(''n'',''x'')&lt;/code&gt;.

; Exemple
: &lt;code&gt;{{pointillés|{}} EQ \r(3;a+b) {{pointillés|} }}&lt;/code&gt;
: donne
: &lt;math&gt;\sqrt[3]{a+b}&lt;/math&gt;.

L'intégrale d'une fonction entre deux bornes ''a'' et ''b'' s'obtient avec &lt;code&gt;\i(''a'';''b'';''fonction'')&lt;/code&gt;, et l'option &lt;code&gt;\in&lt;/code&gt; modifie la position des limites, par exemple
: &lt;code&gt;{{pointillés|{}} EQ \i \in(0;2π;sin(x)dx)=0 }}&lt;/code&gt;
: donne
: &lt;math&gt;\int_0^{2\pi} \sin(x)\mathrm{d}x = 0&lt;/math&gt;
: (le symbole π est intégré comme caractère spécial).

On obtient les sommes et produits en ajoutant des options :
* &lt;code&gt;\i \su(''a'';''b'';''suite'')&lt;/code&gt; : somme ∑ ;
* &lt;code&gt;\i \pr(''a'';''b'';''suite'')&lt;/code&gt; : produit ∏ ;
* &lt;code&gt;\i \fc\A(''a'';''b'';''suite'')&lt;/code&gt; remplace le symbole par un A de taille normale ''(fixed character)'' ; on peut utiliser n'importe quel symbole ;
* &lt;code&gt;\i \vc\A(''a'';''b'';''suite'')&lt;/code&gt; : ''idem'' avec un symbole de taille ajustable ''(vatiable character)''.
Pour la notation des suites, on utilise &lt;code&gt;\s \do(…)&lt;/code&gt; ''(down)'', par exemple
: &lt;code&gt;{{pointillés|{}} EQ x\s\do(2) {{pointillés|} }}&lt;/code&gt;
: donne
: x&lt;sub&gt;2&lt;/sub&gt;.
Le caractère mis en supérieur est de la même taille. On peut mettre le caractère plus bas en précisant le nombre de points typographiques (2 par défaut), par exemple &lt;code&gt;{{pointillés|{}} EQ x\s\do5(2) {{pointillés|} }}&lt;/code&gt; pour descendre de 5 points.

On peut aussi utiliser la mise en inférieur (indice) classique, qui donne un caractère plus petit :
* combinaison de touches {{touche|CTRL}}+{{touche|{{=}}}} ;
* bouton graphique {{bouton|''x''&lt;sub&gt;2&lt;/sub&gt;}} ;
* menu '''Format | Police''', option '''Indice'''.

== Tableaux et matrices ==

Un tableau est contenu dans un code &lt;code&gt;\a()&lt;/code&gt; ''(array)''. Les éléments sont séparés par un point virgule, le nombre de colonne est précisé par l'option &lt;code&gt;\co&lt;/code&gt;. MS Word prend en compte les espaces avant et après le point-virgule.

; Exemple
:&lt;code&gt;{{pointillés|{}} EQ \a \co3(a;b;c;1;2;3) {{pointillés|} }}&lt;/code&gt;
: donne
{|
|- align=&quot;center&quot;
| a || b || c
|- align=&quot;center&quot;
| 1 || 2 || 3
|}

On peut modifier le rendu du code par les options
* &lt;code&gt;\al&lt;/code&gt;, &lt;code&gt;\ac&lt;/code&gt;, &lt;code&gt;\ar&lt;/code&gt; : aligne les lignes respectivement à gauche, au centre et à droite&lt;br /&gt;par exemple &lt;code&gt;{{pointillés|{}} EQ \a \co3\al(aaa;bbb;ccc;1;2;3) {{pointillés|} }}&lt;/code&gt; donne
{|
|-
| aaa || bbb || ccc
|-
| 1 || 2 || 3
|}
* &lt;code&gt;\vs&lt;/code&gt;, &lt;code&gt;\hs&lt;/code&gt; suivi d'un nombre accolé : insert respectivement un espace vertical ''(vertical space)'' entre les lignes ou horizontal ''(horizontal space)'' entre les colonnes, de la valeur en nombre de points.

Pour faire une matrice ou un torseur, on encadre le tableau
* avec des parenthèse &lt;code&gt;\b \bc(…)&lt;/code&gt; ;
* avec des crochets &lt;code&gt;\b \bc\[ (…)&lt;/code&gt; ;
* avec des accolades &lt;code&gt;\b \bc\{ (…)&lt;/code&gt;.
; Exemple
: &lt;code&gt;{{pointillés|{}} EQ \b \bc{{bleu|(}}\a{{vert|(}}a b;1 2{{vert|)}}{{bleu|)}} {{pointillés|} }}&lt;/code&gt; 
: donne
: &lt;math&gt;\begin{pmatrix}a &amp; b \\ 1 &amp; 2\end{pmatrix}&lt;/math&gt;
: et
: &lt;code&gt;{{pointillés|{}} EQ \b \bc\[{{bleu|(}}\a{{vert|(}}a b;1 2{{vert|)}}{{bleu|)}} {{pointillés|} }}&lt;/code&gt; 
: donne
: &lt;math&gt;\begin{bmatrix}a &amp; b \\ 1 &amp; 2\end{bmatrix}&lt;/math&gt;

== Système d'équations ==

Pour faire un système d'équations, on peut associer un tableau à une colonne avec une accolade gauche, par exemple
: &lt;code&gt;{{pointillés|{}} EQ \b \lc\{ (\a(x+y = 5;xy = 2)) {{pointillés|} }}&lt;/code&gt;
: donne
: &lt;math&gt;\left \{ \begin{matrix} x + y = 5 \\ xy = 2\end{matrix}\right .&lt;/math&gt;.
On peut mettre un autre caractère (&lt;code&gt;\(&lt;/code&gt;, &lt;code&gt;\[&lt;/code&gt;). On peut aussi metre un caractère de taille variable après, avec la commande &lt;code&gt;\rc&lt;/code&gt;.

== Filets ==

On peut encadrer un caractère par un filet (trait) avec le code &lt;code&gt;\x&lt;/code&gt; suivi des options suivantes :
* &lt;code&gt;\to(…)&lt;/code&gt; : au dessus ''(top)'', par exemple valeur algébrique ou signe - des indices de Miller ;
* &lt;code&gt;\bo(…)&lt;/code&gt; : en dessous ''(bottom)'' ;
* &lt;code&gt;\le(…)&lt;/code&gt; : à gauche ''(left)'' ;
* &lt;code&gt;\ri(…)&lt;/code&gt; : à droite ''(right)''.
; Exemple
: &lt;code&gt;{{pointillés|{}} EQ \x \bo \to \le \ri(abc) {{pointillés|} }}&lt;/code&gt; 
: donne
: &lt;span style=&quot;border: black solid 1px; padding: 1px 2px 1px 2px;&quot;&gt;abc&lt;/span&gt;.

== Voir aussi ==

* L'aide en ligne de Microsoft Office Word, rubrique « Code de champ : champ EQ (Equation) »
* ({{en}}) [http://office.microsoft.com/en-gb/word/HP051861481033.aspx Field codes: Eq (Equation) field] (Applies to: Microsoft Office Word 2003)

[[Catégorie:Du bon usage d'un traitement de texte (livre)|Annexes]]</text>
      <sha1>ndcx0aejuwu7yl717u4jzthcx7j0le2</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Programmer en deux minutes/l'interface de Wikipédia pour programmer/la librairie d'instructions Pywikipedia</title>
    <ns>0</ns>
    <id>31670</id>
    <revision>
      <id>684228</id>
      <parentid>564695</parentid>
      <timestamp>2022-08-27T12:46:49Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1509" xml:space="preserve">{| width=&quot;100%&quot; border=&quot;0&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot;
 |-
 | bgcolor=&quot;lightblue&quot; align=&quot;center&quot; colspan=&quot;2&quot; |
   {| width=&quot;100%&quot; bgcolor=&quot;lightblue&quot;
    |-
    | bgcolor=&quot;lightblue&quot; valign=&quot;middle&quot; width=&quot;90%&quot; align=&quot;center&quot; | &lt;span style=&quot;font-size:0.63em&quot;&gt;{{SUBPAGENAME}}&lt;/span&gt;

''un chapitre pour « [[Programmer en deux minutes]] »,&lt;br&gt;un livre appartenant à l'[[Accueil/Informatique|étagère Informatique]] de [[Accueil|Wikilivres]]''.
    |}
|}

[[Fichier:Pwb icon.svg|left]]
'''La librairie d'instructions Pywikipedia''' est un ensemble d'objets et de méthodes pour [[Wikimedia/Créer un bot|créer un programme pour éditer les wikis propulsés par MediaWiki]].

Elle est distribuée avec un ensemble de scripts, prêts à l'usage, écrits pour effectuer des tâches de maintenance courantes, telles que la gestion des catégories, &lt;code&gt;category.py&lt;/code&gt;. Ceux-ci sont disponibles sur [http://svn.wikimedia.org/viewvc/pywikipedia/trunk/pywikipedia le tronc de développement de Pywikipedia].

::''Rendez-vous sur '''[[w:Aide:Pywikipedia|l'aide pour utiliser Pywikipedia]]''' pour en apprendre davantage, ou lisez le code du script [http://svn.wikimedia.org/viewvc/pywikipedia/trunk/pywikipedia/basic.py?view=markup '''&lt;code&gt;basic.py&lt;/code&gt;'''].

'''Félicitations''', vous êtes parés pour utiliser une librairie d'instructions Python pour interagir avec un [[Interface de programmation/Services Web|service Web]].

[[Catégorie:Programmation Python (livre)|Programmer en deux minutes]]</text>
      <sha1>m7tr5qhqe95nla4o2nnfjib07mocpjx</sha1>
    </revision>
    <revision>
      <id>684248</id>
      <parentid>684228</parentid>
      <timestamp>2022-08-27T12:58:16Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1511" xml:space="preserve">{| width=&quot;100%&quot; border=&quot;0&quot; cellspacing=&quot;0&quot; cellpadding=&quot;5&quot;
 |-
 | bgcolor=&quot;lightblue&quot; align=&quot;center&quot; colspan=&quot;2&quot; |
   {| width=&quot;100%&quot; bgcolor=&quot;lightblue&quot;
    |-
    | bgcolor=&quot;lightblue&quot; valign=&quot;middle&quot; width=&quot;90%&quot; align=&quot;center&quot; | &lt;span style=&quot;font-size:0.63em&quot;&gt;{{SUBPAGENAME}}&lt;/span&gt;

''un chapitre pour « [[Programmer en deux minutes]] »,&lt;br&gt;un livre appartenant à l'[[Accueil/Informatique|étagère Informatique]] de [[Accueil|Wikilivres]]''.
    |}
|}

[[Fichier:Pwb icon.svg|left]]
'''La librairie d'instructions Pywikipedia''' est un ensemble d'objets et de méthodes pour [[Wikimedia/Créer un bot|créer un programme pour éditer les wikis propulsés par MediaWiki]].

Elle est distribuée avec un ensemble de scripts, prêts à l'usage, écrits pour effectuer des tâches de maintenance courantes, telles que la gestion des catégories, &lt;code&gt;category.py&lt;/code&gt;. Ceux-ci sont disponibles sur [http://svn.wikimedia.org/viewvc/pywikipedia/trunk/pywikipedia le tronc de développement de Pywikipedia].

::''Rendez-vous sur '''[[w:Aide:Pywikipedia|l'aide pour utiliser Pywikipedia]]''' pour en apprendre davantage, ou lisez le code du script [http://svn.wikimedia.org/viewvc/pywikipedia/trunk/pywikipedia/basic.py?view=markup '''&lt;code&gt;basic.py&lt;/code&gt;'''].''

'''Félicitations''', vous êtes parés pour utiliser une librairie d'instructions Python pour interagir avec un [[Interface de programmation/Services Web|service Web]].

[[Catégorie:Programmation Python (livre)|Programmer en deux minutes]]</text>
      <sha1>olubkkvjeu5rc6daihjlesyelrzff76</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Programmer en deux minutes/Bas de page</title>
    <ns>0</ns>
    <id>31836</id>
    <revision>
      <id>684237</id>
      <parentid>547878</parentid>
      <timestamp>2022-08-27T12:52:07Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="680" xml:space="preserve">::Pour aller plus loin : [[:Catégorie:Programmation]].
:::... [[Programmation Python/Programmer en deux minutes|en deux minutes avec Python]] :
:::*[[Programmation Python/Programmer en deux minutes/une messagerie instantanée|une messagerie instantanée]],
:::*[[Programmation Python/Programmer en deux minutes/l'interface de Wikipédia pour programmer|un programme en interface avec Wikipédia]],
:::*[[Programmation Python/Programmer en deux minutes/un serveur Web|un serveur Web]] pour partager des fichiers et mettre en ligne un site statique en HTML.


::''Voir aussi le livre : [[Programmer en deux minutes]]''

[[Catégorie:Programmer en deux minutes (livre)]]
{{AutoCat}}</text>
      <sha1>rf38lxqm3cgw0o7rus68j4xoyjnwipc</sha1>
    </revision>
  </page>
  <page>
    <title>Le langage CSS/Le positionnement des éléments</title>
    <ns>0</ns>
    <id>32086</id>
    <revision>
      <id>684224</id>
      <parentid>678401</parentid>
      <timestamp>2022-08-27T12:39:16Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10861" xml:space="preserve">&lt;noinclude&gt;{{CSS}}&lt;/noinclude&gt;

== Initiation au positionnement en CSS ==

Pour éviter l'usage inconsidéré des tableaux de mise en page, l'utilisation correcte de chaque élément (balises &lt;code&gt;div&lt;/code&gt;, &lt;code&gt;p&lt;/code&gt;, &lt;code&gt;h1&lt;/code&gt;, &lt;code&gt;ul&lt;/code&gt;, &lt;code&gt;li&lt;/code&gt; etc.) ainsi que leur positionnement en CSS est dorénavant indispensable.

Les éditeurs HTML visuels n'utilisent qu'une infime partie des possibilités des balises (faussement nommées « calques » en général), ce qui les rend souvent peu compatibles et peu pratiques.

Cet article en deux parties explique comment positionner les éléments en CSS de façon optimale.

Voici les principaux points à retenir de cet article :

* Tous les éléments (balises) HTML peuvent être positionnés, décorés, dimensionnés… grâce aux styles CSS. Cela signifie que les CSS ne s'appliquent pas qu'aux éléments &lt;nowiki&gt;&lt;div&gt;&lt;/nowiki&gt; contrairement à certaines idées reçues : une image (&lt;code&gt;&lt;nowiki&gt;&lt;img&gt;&lt;/nowiki&gt;&lt;/code&gt;), une liste (&lt;code&gt;&lt;nowiki&gt;&lt;ul&gt;&lt;/nowiki&gt;&lt;/code&gt;), un paragraphe (&lt;code&gt;&lt;nowiki&gt;&lt;p&gt;&lt;/nowiki&gt;&lt;/code&gt;), etc. peuvent être stylés en CSS sans avoir besoin d'être contenus dans un élément &lt;code&gt;&lt;nowiki&gt;&lt;div&gt;&lt;/nowiki&gt;&lt;/code&gt;. Évitez d'ailleurs de surcharger vos documents d'éléments &lt;code&gt;&lt;nowiki&gt;&lt;div&gt;&lt;/nowiki&gt;&lt;/code&gt; inutiles.
* Employez toujours les éléments selon leur fonction et non selon leur aspect (puisque cet aspect pourra facilement être modifié via CSS) : un paragraphe sera défini par la balise &lt;code&gt;&lt;nowiki&gt;&lt;p&gt;&lt;/nowiki&gt;&lt;/code&gt;, un titre par la balise &lt;code&gt;&lt;nowiki&gt;&lt;h1&gt;&lt;/nowiki&gt;&lt;/code&gt;, &lt;code&gt;&lt;nowiki&gt;&lt;h2&gt;&lt;/nowiki&gt;&lt;/code&gt;… Notez que l'élément &lt;code&gt;&lt;nowiki&gt;&lt;div&gt;&lt;/nowiki&gt;&lt;/code&gt; est neutre est sert de « bouche-trou » pour englober d'autres éléments ou servir lorsqu'aucun autre élément n'est approprié. N'utilisez pas &lt;code&gt;&lt;nowiki&gt;&lt;div&gt;&lt;/nowiki&gt;&lt;/code&gt; pour englober des éléments seuls !
* Il existe deux types généraux d'éléments HTML : les balises de type « en-ligne » et les balises de type « bloc ». Cette différence est fondamentale et a de nombreuses implications sur les styles qui peuvent être appliqués.
* L'imbrication des éléments les uns dans les autres, et les notions de parenté (parent, ancêtre, frère…) permettent de styler facilement les éléments en utilisant cette hiérarchie dans les sélecteurs CSS. Cela évite d'employer des noms de classes ou d'id multiples et inutiles, qui complexifient la lecture et la compréhension des styles.
* Il existe plusieurs schémas de positionnement en CSS : un schéma de positionnement dans le Flux (positionnement par défaut), et trois schémas de positionnement qui sortent l'élément du Flux (positionnement absolu, positionnement fixé et positionnement flottant). Un dernier « positionnement » (relatif) est en fait une variante du positionnement courant qui provoque un décalage. La notion de Flux est fondamentale.
* Chaque schéma de positionnement a ses règles et spécificités. Mieux vaut bien comprendre ces règles pour éviter des interactions ou des comportements non désirés… et déclarer que les CSS ne fonctionnent pas ! :)

== Les balises de bloc et les balises en-ligne ==

Ce chapitre sur la structure des balises est primordial, vous devez auparavant avoir consulté le didacticiel sur les bloc/en-ligne.

Voici un résumé pour les lecteurs pressés 

* les éléments de rendu « bloc » se placent toujours l'un en dessous de l'autre par défaut (comme un retour chariot). Par exemple : une suite de paragraphes (balise &lt;code&gt;&lt;nowiki&gt;&lt;p&gt;&lt;/nowiki&gt;&lt;/code&gt;) ou les éléments d'une liste (balise &lt;code&gt;&lt;nowiki&gt;&lt;li&gt;&lt;/nowiki&gt;&lt;/code&gt;). Par ailleurs, un élément « bloc » occupe automatiquement, par défaut, toute la largeur disponible dans son conteneur.
* les éléments de rendu « en-ligne » se placent toujours l'un à côté de l'autre afin de rester dans le texte. Par exemple : le renforcement d'une partie de texte à l'aide de la balise.
* les autres éléments de type en-ligne (« non-remplacés ») n'ont pas de dimension à proprement parler par défaut (il n'occupent que la place minimum nécessaire à leur contenu). C'est le cas des éléments &lt;code&gt;&lt;nowiki&gt;&lt;strong&gt;&lt;/nowiki&gt;&lt;/code&gt;, &lt;code&gt;&lt;nowiki&gt;&lt;em&gt;&lt;/nowiki&gt;&lt;/code&gt;, &lt;code&gt;&lt;nowiki&gt;&lt;span&gt;&lt;/nowiki&gt;&lt;/code&gt; etc.

== Ancêtre, Parents, Enfants, Frères == 

Comprendre l'imbrication des éléments (boîtes) les uns dans les autres est essentiel.

Chaque document HTML est toujours composé de conteneurs. Ceux-ci peuvent être ancêtres, parents, enfants ou frères. Ces différents éléments composent une hiérarchie d'imbrications.

* Un élément « ancêtre » est un élément qui contient un élément ou une hiérarchie d'éléments
* Un bloc « parent » est un élément contenant directement un autre bloc. Par exemple, un &lt;code&gt;DIV&lt;/code&gt; contenant un paragraphe &lt;code&gt;P&lt;/code&gt;. Attention : si ce paragraphe contient lui-même des éléments (ex : &lt;code&gt;strong&lt;/code&gt;), &lt;code&gt;DIV&lt;/code&gt; ne sera pas parent de l'élément &lt;code&gt;strong&lt;/code&gt; mais uniquement son ancêtre. Le parent est donc l'ancêtre immédiat.
* Un bloc contenu directement dans un autre bloc est dit « enfant » de cet élément. Par exemple, ici les éléments &lt;code&gt;LI&lt;/code&gt; sont enfants de leur conteneur &lt;code&gt;UL&lt;/code&gt;.
* Les éléments ayant le même élément parent sont appelés « frères ».

== Le flux ==

La mise en place des différents éléments de la page se fait par défaut selon le flux courant.

Les éléments (balises) sont placés les uns après les autres dans le code HTML de la page.

L'ordre dans lequel apparaissent les balises dans le code HTML sera l'ordre dans lequel ils seront affichés et apparaîtront dans le document, c'est le flux. Cela signifie que, par défaut, chaque élément est dépendant des éléments frères qui l'entourent.

Par défaut, les balises « bloc » et les balises « en-ligne » ont un comportement différent dans le flux normal (voir tutoriel sur la structure des balises).

NOTE : les blocs positionnés en « absolu » ou « fixé » sortent du flux naturel et échappent quelque peu à cette règle.
Ils ne sont alors plus dépendant des éléments frères.
Pour se placer, un tel bloc se réfère non pas à son Parent direct, mais au premier Ancêtre positionné qu'il rencontre.

Sachez utiliser chaque balise à bon escient !

* Il est souvent inutile de faire des imbrications multiples de &lt;code&gt;&lt;nowiki&gt;&lt;div&gt;&lt;/nowiki&gt;&lt;/code&gt;, ceux-ci ne servant qu'à délimiter des zones de page
* Évitez d'utiliser les balises &lt;code&gt;&lt;nowiki&gt;&lt;table&gt;&lt;/nowiki&gt;&lt;/code&gt; pour la mise en page de votre site : ils ne sont pas fait pour ça mais pour des données tabulaires et statistiques
* Utilisez les balises &lt;code&gt;&lt;nowiki&gt;&lt;h1&gt;&lt;/nowiki&gt;&lt;/code&gt;...&lt;code&gt;&lt;nowiki&gt;&lt;h6&gt;&lt;/nowiki&gt;&lt;/code&gt; pour vos titres et non des balises &lt;code&gt;&lt;nowiki&gt;&lt;p&gt;&lt;/nowiki&gt;&lt;/code&gt; améliorées
* Utilisez les listes &lt;code&gt;&lt;nowiki&gt;&lt;ul&gt;&lt;/nowiki&gt;&lt;/code&gt; &lt;code&gt;&lt;nowiki&gt;&lt;li&gt;&lt;/nowiki&gt;&lt;/code&gt; pour vos menus, car leur utilisation est tout à fait appropriée pour ça (voir les articles de la catégorie « menus en CSS »)

== Alignement de blocs tels que les images ==
Centrer un bloc requiert une technique bien différente de celle pour centrer un texte :
&lt;syntaxhighlight lang=css&gt;
    width: 50%;
    display: block;
    margin: auto;
&lt;/syntaxhighlight&gt;

== Position relative et absolue ==
On distingue cinq sortes de positionnement, correspondant aux valeurs de la propriété &lt;code&gt;position&lt;/code&gt;&lt;ref&gt;https://developer.mozilla.org/fr/docs/Web/CSS/position&lt;/ref&gt; :
# &lt;code&gt;static&lt;/code&gt; : (statique) Les éléments se placent dans l'ordre où ils apparaissent dans le code source, les propriétés de positionnement sont ignorées. C'est le positionnement par défaut quand il n'est pas précisé.
# &lt;code&gt;relative&lt;/code&gt; : (relatif) Les éléments sont positionnés relativement par rapport à la position courante du nombre spécifié par les propriétés &lt;code&gt;left&lt;/code&gt;, &lt;code&gt;right&lt;/code&gt;, &lt;code&gt;top&lt;/code&gt;, &lt;code&gt;bottom&lt;/code&gt;. Attention : si &lt;code&gt;left&lt;/code&gt; est défini, &lt;code&gt;right&lt;/code&gt; est ignoré, et si &lt;code&gt;top&lt;/code&gt; est défini, &lt;code&gt;bottom&lt;/code&gt; est ignoré.
# &lt;code&gt;absolute&lt;/code&gt; : (absolu) Les éléments sont positionnés en absolu par rapport au coin supérieur gauche du bloc qui les contient.
# &lt;code&gt;fixed&lt;/code&gt; : (fixe) Les éléments sont positionnés relativement par rapport à la fenêtre du navigateur. Ils ne bougent pas dans la fenêtre quand on fait défiler son contenu.
# &lt;code&gt;sticky&lt;/code&gt; : (attaché) Mixant les modes statiques et fixés, les éléments sont positionnés de manière statique relativement par rapport à la position courante excepté lorsque le défilement les rendraient cachés, auquel cas ils sont positionnés relativement par rapport à la fenêtre du navigateur : ils ne bougent pas dans la fenêtre quand on fait défiler son contenu, jusqu'à ce que l'élément parent qui les contient ne soit plus visible.

Exemple :
&lt;syntaxhighlight lang=html5&gt;
&lt;div style=&quot;border-style: solid;&quot;&gt;
	&lt;p style=&quot;position: static; bottom: 5px; left: 50px;&quot;&gt;Statique&lt;/p&gt;&lt;br/&gt;
	&lt;p style=&quot;position: relative; bottom: 5px; left: 50px;&quot;&gt;Relative&lt;/p&gt;&lt;br/&gt;
	&lt;p style=&quot;position: absolute; bottom: 5px; left: 50px;&quot;&gt;Absolue&lt;/p&gt;&lt;br/&gt;
	&lt;p style=&quot;position: fixed; bottom: 5px; left: 50px;&quot;&gt;Fixe&lt;/p&gt;&lt;br/&gt;
&lt;/div&gt;
&lt;/syntaxhighlight&gt;
donne :
&lt;div style=&quot;border-style: solid;&quot;&gt;
	&lt;p style=&quot;position: static; bottom: 5px; left: 50px;&quot;&gt;Statique&lt;/p&gt;&lt;br/&gt;
	&lt;p style=&quot;position: relative; bottom: 5px; left: 50px;&quot;&gt;Relative&lt;/p&gt;&lt;br/&gt;
	&lt;p style=&quot;position: absolute; bottom: 5px; left: 50px;&quot;&gt;Absolue&lt;/p&gt;&lt;br/&gt;
	&lt;p style=&quot;position: fixed; bottom: 5px; left: 50px;&quot;&gt;Fixe&lt;/p&gt;&lt;br/&gt;
&lt;/div&gt;
(on voit la position statique non affectée par le décalage, puis la relative décalée en-dessous, le fixe est en bas à gauche de la fenêtre et l'absolue en bas du contenu de celle-ci).

== Éléments flottant ==
[[Image:cssposfloat.png|thumb|Exemple d'élément flottant (en rouge). La présente image est également un élément flottant à droite du wikilivre (le texte qui la suit est remonté à sa gauche).]]
La propriété &quot;float&quot; permet aux éléments de flotter dans le flux normal. Les boites bougent alors à gauche ou à droite jusqu'à la limite de leur conteneur. Les éléments situés après un flottant sont alors remontés pour combler le trou laissé autour de ce dernier. 

La propriété &quot;float&quot; ne peut donc prendre que les valeurs &quot;left&quot; ou 'right&quot;. Pour que cela fonctionne, il faut aussi définir la propriété &lt;code&gt;width&lt;/code&gt; du flottant, sinon il occupe toute la largeur de son conteneur.

Exemple :

&lt;syntaxhighlight lang=&quot;CSS&quot;&gt;
    border: 1px solid #F00;
    float: left;
    width: 425px;
&lt;/syntaxhighlight&gt;

== Références ==
{{Références}}</text>
      <sha1>le2we7indhto47b2w5hyswfvycm4n0r</sha1>
    </revision>
  </page>
  <page>
    <title>Introduire la biodiversité dans la construction et l'urbanisme/Les étapes dans l'élaboration d'un projet de prise en compte de la biodiversité dans la construction/Préparer l'évaluation environnementale</title>
    <ns>0</ns>
    <id>32515</id>
    <revision>
      <id>684308</id>
      <parentid>485405</parentid>
      <timestamp>2022-08-27T18:45:32Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="11462" xml:space="preserve">En France, le nouvel objectif n°6 du nouveau cadre de référence de la démarche HQE (au sens de l’association HQE) est « prise en compte de la nature et de la biodiversité » ;
Une bonne évaluation cherche à mesurer (quantitativement et qualitativement) divers paramètres (état, pression, réponse en général). 
&lt;br /&gt;Elle peut être itérative (tous les 5 ans en général pour une réserve naturelle), ou permanente. 
&lt;br /&gt;Dans tous les cas, elle se prépare et nécessite une stratégie (itérative, évolutive), quelques outils spécifiques, et quelques compétences et moyens.

== Une stratégie d'évaluation ==
Elle vise à mesurer un progrès par rapport à une situation antérieure et un objectif. Pour cela elle s'appuie sur les résultats d'un ''« [[w:fr:Biomonitoring|biomonitoring]] »'' exploitant des données provenant par exemple de  ;
* un état initial des lieux, et dans la mesure du possible sur un ''« [[w:Histoire environnementale|historique du site]] »'' et de son environnement (cf. [[w:Écologie rétrospective|écologie rétrospective]]) incluant une évaluation de l'[[w:fr:écopotentialité|écopotentialité]] du site ;
* un Monitoring écologique, qui porte généralement sur la faune, la flore, la fonge, les écosystèmes, l'intégrité et la fonctionnalité des trames du réseau écologique ; 
* un Monitoring paysager : Il est utile de pouvoir photographier l'évolution du paysage et de la flore (printemps, été, automne, hiver si possible) en quelques points stratégiques (choisis de manière à permettre le meilleur suivi)...
* des enquêtes ;
* une analyse des freins, échecs et progrès.

En 2015 en France, l'Association HQE et Orée ont lancé un appel à test HQE Performance (le 21 juillet 2015) dans le cadre du développement du nouvel objectif n°6 du nouveau cadre de référence de la démarche HQE (au sens de l’association HQE) qui est {{Citation|prise en compte de la nature et de la biodiversité}} ;  Ces deux associations françaises (HQE et Orée), deux ans après avoir créé un groupe de travail commun, {{Citation|Biodiversité et bâtiment}}, et à l’initiative de ce dernier, ont publié mi 2015 un {{Citation|appel à test HQE Performance}} centré sur la biodiversité, dans le cadre du projet « HQE Performance ». Cet appel peut concerner tout type de bâtiments, (engagés ou non en certification). L’appel est clos de 1er septembre 2015, les tests (basés sur la démarche ''{{Citation|Biodi(V)strict]]''  décrite plus bas) doivent être faits avant le 1er décembre pour publication finale au second semestre 2016). Ceci vise à mieux tenir compte du retour d’expérience des utilisateurs et à produire des valeurs de référence. Un travail similaire avait déjà été fait sur les notions d'analyse de cycle de vie, d'air intérieur et d’acoustique&lt;ref name=TestBiodiv2015&gt;[http://assohqe.org/hqe/IMG/pdf/150626_plaquette_appel_a_test_Biodiv.pdf Appel à test HQE Performance Biodiversité 2015], et [http://assohqe.org/hqe/IMG/pdf/150626_plaquette_appel_a_test_Biodiv.pdf appel à projet], consulté 2015-07-21 &lt;/ref&gt;.

== Outils ==
Parmi les outils possibles:
* un [[w:Observatoire de la biodiversité|observatoire de la biodiversité]] (dans le meilleur des cas)
* un système d'information géographie (SIG) est indispensable pour le suivi des grand sites ou de constellations de petits sites
* outils d'analyse automatiques
* outils photographiques
* Biodi(V)strict : démarche basé sur 5 indicateurs de potentiel écologique du site (capacité, et qualité écologique du site avant et après, à ne pas confondre avec l’[[écopotentialité]]), visuellement représetnés par un diagramme en radar présentant le potentiel écologique avant et après projet ; il aide à cerner les grands enjeux écologiques du projet et à cibler des actions de rstauration, protection ou gestion de la biodiversité sur le site du projet, étudié dans son contextes biogéographique et de trame verte et bleue&lt;ref name=TestBiodiv2015/&gt;, élaboré par la chaire Ecoconception d'AgroParisTech {{Citation|pour l’amélioration du potentiel écologique d’un projet immobilier}})&lt;ref name=TestBiodiv2015/&gt;

==Compétences==
l'évaluation doit être pluridisciplinaire (d'autant plus qu'elle portera sera thématiquement élargie). 
Les compétences nécessaires peuvent varier selon le site, sa taille et les enjeux et le degré d'ambition de l'évaluation.
* écologue (avec compétence en biogéographie, écologie du paysage, écologie urbaine) 
* biologistes (botaniste, ornithologue, mycologue, hydrobiologiste...)
* cartographe
* animateur, 
* enquêteur
* gestionnaire de budget le cas échéant 

[[Catégorie:Introduire la biodiversité dans la construction et l'urbanisme (livre)|Les étapes dans l'élaboration d'un projet de prise en compte de la biodiversité dans la construction]]

===Index de biodiversité urbaine===
[[Image:Index_indicateur_biodiversit%C3%A9_urbaine_URBIO.jpg|thumb|500px]]
Un index (ou indicateur) de biodiversité urbaine (« City Biodiversity Index » ou CBI) a été formulé en Février 2009, à [[w:Singapour|Singapour]], sur proposition de Singapour&lt;ref&gt;[http://www.cop10.jp/citysummit/english/images/biodiversity/02%20City%20Biodiversity%20Index%20-%20Singapore.URBIO.pdf City Biodiversity Index], URBIO 2010, 21 Mai 2010, Nagoya&lt;/ref&gt;, Nagoya  Mr. Tsuyoshi Ito, Mai 2010 ), et sous l'égide du  Secrétariat de la CDB lors d’un premier atelier, avec l’aide de 17 experts de 10 pays et un groupe d'étude technique: 

Cet index est conçu pour être à la fois un outil d'évaluation d’état et de résultats ou d'[[w:écopotentialité|écopotentialités]] urbaines. Il est destiné à montrer – pour la biodiversité urbaine -  à la fois les changements ou tendance en matière d’état, de pression et de réponse &lt;ref&gt;[http://www.cop10.jp/citysummit/english/images/biodiversity/05%20Kohsaka_URBIO2010_CBI.pdf Urban Biodiversity Indicators and DPSIR](Dr. Ryo Kohsaka [Nagoya City Univ.])&lt;/ref&gt;, (ce qui correspond aux types d’indicateurs recommandés et utilisés par l’[[w:OCDE|OCDE]] et l'[[w:Union européenne|Union européenne]]. 

Il doit aussi pouvoir être aussi une aide à la [[w:Gestion restauratoire|gestion restauratoire]] de la biodiversité urbaine sera présenté à Nagoya et plus largement aider les gouvernements nationaux et les autorités locales à  incorporer conservation de la biodiversité considérations dans le contexte urbain ;

Il se veut un outil :
*  d'[[Auto-évaluation|auto-évaluation]] ; 
*  facile à appliquer et utiliser ;
*  scientifiquement [[w:Crédibilité|crédible]]s ; 
*  objectif et équitable.
 
====Les indicateurs retenus pour l'Index====
* '''indicateurs biodiversité urbaine native'''. &lt;br /&gt;1. Taux (%) de ressources naturelles et de zones semi-naturelles  &lt;br /&gt;2.  Diversité des écosystèmes  &lt;br /&gt;3. Mesure de la fragmentation écologique &lt;br /&gt;4. Biodiversité indigène dans le bâti &lt;br /&gt;5 à 9.  Espèces indigènes :.Plantes, Oiseaux, Papillons  + 2  espèces à choisir . &lt;br /&gt;10. Taux (%) d'aires protégées  &lt;br /&gt;11. Proportion d'espèces exotiques invasives 
* '''Services écosystémiques dépendants de la biodiversité''' &lt;br /&gt;12. Services liés aux eaux douces (Coût d'épuration) &lt;br /&gt;13. [[w:Puits de carbone|Puits de carbone]] (arbre en ville)&lt;br /&gt;14. [[w:Aménité|Aménité]]s (récréation et  éducation ; nb visites / personne / an) &lt;br /&gt;15. Surf. et % de la ville en [[w:Parc urbain|Parcs urbains]] et  [[w:Aire protégée|aires protégées]],  Surface  par habitant  de la ville &lt;br /&gt;16. Nb de de [[w:éducation à l'environnement|visites éducatives ]] dans les parcs ou [[w:Réserve naturelle|réserves naturelles]] par an  (moins de 16 ans/an)  
* '''Gouvernance et management de la biodiversité urbaine''' &lt;br /&gt;17. [[w:Budget|Budget]] consacré à la biodiversité &lt;br /&gt;18. Nb. de projets &amp; programmes organisés par la Ville / an  &lt;br /&gt;19. [[w:Droit de l'environnement|Protection réglementaire]], Plans d'action locaux pour la biodiversité &lt;br /&gt;20. Nb.d'établissements couvrant les fonctions essentielles de la biodiversité &lt;br /&gt;21. Nb. de coordinations inter-agences &lt;br /&gt;22. Processus de consultation  &lt;br /&gt;23. Partenariats existants  &lt;br /&gt;24. Biodiversité  dans les programmes scolaires &lt;br /&gt;25. Nb. de programmes  et événements de sensibilisation

== Voir aussi ==
[[Introduire la biodiversité dans la construction et l'urbanisme|Introduire la biodiversité dans la construction et l'urbanisme]] (wikibook en cours d'élaboration)

=== Liens internes ===
&lt;div style='-moz-column-count:3; -moz-column-gap:10px;'&gt;
* [[w:Évaluation environnementale|Évaluation environnementale]]
* [[w:Urbanisme|Urbanisme]]
* [[w:Écologie urbaine|Écologie urbaine]]
* [[w:Biodiversité|Biodiversité]]
* [[w:Biodiversité dans le bâti et le jardin|Biodiversité dans le bâti et le jardin]]
* [[w:Espaces verts écologiques|Espaces verts écologiques]]
* [[w:Haute qualité environnementale|HQE]]
* [[w:Mur végétalisé|Mur végétalisé]]
* [[w:Terrasse végétalisée|Terrasse végétalisée]]
* [[w:Trame verte et bleue|Trame verte et bleue]]
* [[w:Réseau écologique|Réseau écologique]]
* [[w:Écopotentialité|Écopotentialité]]
* [[w:Services écosystémiques|Services écosystémiques]]
* [[w:Écoconception|Écoconception]]
* [[w:Gestion différentiée|Gestion différentiée]]
* [[w:Gestion restauratoire|Gestion restauratoire]]
* [[w:Conférence mondiale sur la biodiversité, de Nagoya (2010)|Conférence mondiale sur la biodiversité, de Nagoya (2010)]]
&lt;/div&gt;

=== Bibliographie ===
* Philippe Clergeau (écologue, Inra Rennes) ''« Une écologie du paysage urbain »'', Éditeur : Apogée, septembre 2007, 136 pages, ISBN 2-84398-288-X et ISBN 978-2-84398-288-0
* «'' La Nature dans la ville ; Biodiversité et urbanisme'' », Avis &amp; Rapport du [[Conseil économique et social (France)|Conseil économique et social]] français, Éditions des Journaux officiels. ([http://www.ces.fr/rapport/doclon/07110324.pdf Télécharger ce rapport])
* Ekhart Hahn, ''Okologische Stadtplanung'', Haag &amp; Herchen, Frankfurt, 1987
* Ekhart Hahn, {{lang|en|''Ecological Urban Restructuring, Theoretical foundation and concept for action''}}, Wissenschaftszentrum  - Paper FS II 91-402, Berlin, 1991 ([http://www.biopolitics.gr/HTML/pubs/vol3/qi-sim.htm Lien])
* David Rudlin et Nicholas Falk, {{lang|en|''Building the 21st Century Home - The Sustainable Urban Neighbourhood''}}, Architectural Press, Oxford, 1999
* Douglas Farr, {{lang|en|''Sustainable Urbanism - urban design with nature''}}, Wiley, Hoboken, 2008, 304 pages, ISBN 978-0-471-77751-9
* Bernard Reygrobellet ; La nature dans la ville, Biodiversité et urbanisme], 2007 ; Les éditions des Journaux officiels ; Avis et rapports du conseil économique et social, ([http://lesrapports.ladocumentationfrancaise.fr/BRP/074000752/0000.pdf télécharger la version pdf], 182 pages).

=== Liens externes ===
* ({{fr}}) et {{en}} [http://www.urbiz.fr/ Urbiz: Recensement des bonnes pratiques en écologie urbaine et centre de ressources documentaires]
* ({{fr}}) [http://web.archive.org/web/20070927235755/http://www.apur.org/images/notes4pages/4P13.pdf Exemple d'application à Paris ; le &quot;coefficient biotope&quot;]
* ({{en}}) [http://www.iclei.org/ page d'accueil de l'ICLEI]


== Notes et références ==
{{Références|colonnes=2}}</text>
      <sha1>0kprtc4n3ui20co10kl2srvqlv6woq1</sha1>
    </revision>
  </page>
  <page>
    <title>Introduire la biodiversité dans la construction et l'urbanisme/Préalables ; principes généraux et transversaux</title>
    <ns>0</ns>
    <id>32598</id>
    <revision>
      <id>684310</id>
      <parentid>468317</parentid>
      <timestamp>2022-08-27T18:47:03Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16203" xml:space="preserve">=='''Introduction'''==
Certaines notions et principes propres à l'architecture, à l'écologie ou encore à la  psychée humaine sont par nature associés aux sujets traités dans ce livre. &lt;br /&gt;Certains d’entre eux sont aussi des conditions nécessaires (et hélas non suffisantes) à la réussite de toute démarche visant à restaurer les conditions d'un réconciliation profonde de l'architecture et de la nature.
&lt;br /&gt;Ils seront rappelés ou seront transversalement présents dans l'ensemble des chapitres.
 
='''Principes généraux :'''=
L'[[w:écologie du paysage|écologie du paysage]], la biologie de la conservation, appliquées à l'espace urbain, périurbain ou construit offrent maintenant un cadre théorique et pratique à l'analyse de la nature et naturalité des milieux construits, et de leurs impacts sur les milieux naturels.

===Développement durable et soutenable===
[[Image:Schéma du développement durable.svg|thumb|left|350px|'''''Figure 1 :''''' Les thèmes et enjeux généraux, mais majeurs, de [[w:Développement durable|soutenabilité du développement]], et leurs interelations]]
[[File:3x3 rondsLamiotWikimediaCommons.jpg|thumb|right|350px|'''''Figure 2 : ''''' Comment agir, et avec quelles ressources pour quels objectifs ? Ce graphique présente les interrelations qui lient les grands domaines (ou enjeux) du développement durable.]]
[[Image:Ukraine. Kamenets-Podolsky.jpg|thumb|350px|Un principe de base est - dans une certaine mesure (dans les limites qu'autorisent la préservation de l'infrastructure bâtie, et la sécurité notamment) - l'imitation des processus naturels. Si dans la nature, même des parois verticales et minérales ultrapauvres en nutriments peuvent abriter la vie (ici sur des falaises en Ukraine), l'architecte et l'urbaniste doivent pouvoir aménager le bâti pour y intégrer plus de biodiversité que dans le bâti tratitionnel]]
[[image:EVA- Lanxmeer Greenhouse7 2009.jpg|thumb|350px|Tout en restant, dans une certaine mesure, ''sous contrôle'' la nature peut entrer dans une partie de l'espace habité (écoquartier d'[[w:fr:Eva-Lanxmeeer|Eva-Lanxmeer]], aux Pays-Bas]]

Un premiers cadre, très général, est transversal à la plupart des démarches de prise en compte du Vivant dans l'urbanisme et le bâti. 
C'est celui du '''''« [[w:Développement soutenable|développement soutenable]] »''''' (ou ''« durable »''), désormais classiquement représenté comme à l'interface des trois sphères représentées par la  '''''figure 1 ''''' (trois sphères ; environnementales, sociales et écologiques.. certains y ajoutant un 4ème pilier qui serait la culture, ici intégré dans la sphère du social). 


La '''''figure 1''''' (ci-contre à gauche) présente l'intérêt de rappeler que tout projet se voulant soutenable devrait au minimum répondre, et de manière équilibrée à ces préoccupations. &lt;br /&gt;Concernant le sujet de cet ouvrage, les interfaces '''''« Vivable »''''' et '''''« Viable »''''' prendront une importance particulière, à la fois comme « condition » et « résultat » des projets réussis. 


La '''''figure 2 ''''', un peu plus complexe, mais plus précise, ajoute d'autres enjeux et thèmes aux précédents. Tous les thèmes qu'elle présente sont au moins pour partie fonctionnellement interdépendants.  
&lt;br /&gt;Les zones d'intersections entre les sphères ou groupes de sphères du graphique représentent les interfaces (deux à deux, ou trois à trois) entre les items de base. par exemple la zone d'interface entre la spère «''''' Gérer '''''» et la sphère «''''' Restaurer'''''» est à comprendre comme représentant le domaine de la « '''''[[w:Gestion restauratoire|gestion restauratoire]]''''' ». &lt;br /&gt;Ce diagramme décrit dans la ''« sphère des actions »'' la nécessité de '''restaurer''', '''protéger''' et '''gérer''' des '''ressources'''. Ces ressources (eau, air, sol, faune, flore, fonge...) sont toutes vitales pour l'homme et les autres espèces. Elles sont produites ou entretenues par la biodiversité, via les écosystèmes. Dans chaque projet, ces ressources peuvent, selon le contexte et les impacts du projet être classées et hiérarchisées comme étant : pas, peu, difficilement, coûteusement ou lentement renouvelables. Ces ressources sont nécessaires à l'atteinte des objectifs qui sont à la fois sociaux, économiques et donc environnementaux. 
&lt;br /&gt;Tout projet se voulant cohérent du point de vue environnemental et durable, devrait prendre en compte chacun des aspects figuré par une sphère ainsi que par chaque intersection entre deux ou trois sphère.
&lt;br /&gt;Ce graphique, assez facile à mémoriser. Dans le domaine complexe de l'[[w:Évaluation environnementale|évaluation environnementale]], il permet de garder une vue globale et systémique d'un problème (une étude d'impact, un projet, un agenda 21, une situation individuelle ou collective, etc.). Il peut à ce titre  -pour partie - servir de première check-list dans l'exploration des enjeux environnementaux de n'importe quel projet (architectural ou urbain dans les cas qui nous préoccupe dans cet ouvrage). Ce diagrame ne prend tout son sens et toute son utilité que si son utilisateur analyse les impacts positifs et négatifs, immédiats et différés dans le temps (court, moyen et long terme) et dans l'espace (impacts locaux à globaux). Il est en quelque sorte conçu pour aider à faire ce travail sans rien oublier d'important. 

On peut d'aussi y associer le ''« triangle éthique »'' (voir chapitre [[Pourquoi intégrer la biodiversité dans l'architecture/Approche éthique|Approche éthique]])  qui pourra aider le porteur de projet à hiérarchiser certains enjeux ; par exemple dans ou sur une crèche, d'une maternité, d'un hôpital, d'une maison de retraite, d'une école, la contribution de la biodiversité à épurer l'air et l'eau pourra être surpondérée dans l'évaluation des enjeux et priorités.

Les principes du développement dit ''« soutenable »'', incluent la restauration, protection et gestion de la biodiversité. Ils semblent relever souvent du simple bon sens mais les architectes habitants, et usagers du patrimoine bâti ne savent pas toujours comment les transcrire ou les appliquer au mieux. Plus précisément les principes et critères de la [[w:Haute qualité environnementale|Haute qualité environnementale]] des éléments construits seront fréquemment évoqués.

===Chaque projet est un cas particulier, mais toujours à lier à l'environnement global===
Parce que portant sur le vivant, et s'inscrivant dans des contextes toujours différents, chaque projet d'intégration de la biodiversité dans la construction sera différent des autres, sans pour autant pouvoir être autonome car devant s'inscrire dans le ''réseau écologique local'' ou ce qui en reste, ce qui nécessite la prise en compte de l’environnement proche (atout, contraintes) et de l'écopotentialité du site ;

En France, on pourra par exemple s'appuyer sur les [[w:fr:Inventaire communal de la biodiversité|inventaires communaux de la biodiversité]] (quand ils existent), sur les documents nationaux et régionaux ([[w:fr:SRCE|SRCE]]) la [[w:fr:Trame verte et bleue|trame verte et bleue]] en s'intéressant notamment au travail de de prise en compte de la biodiversité (ordinaire ou non) dans les SCOTs (par exemple, dans le nord de la France, l'observatoire de la biodiversité du Nord-Pas-de-Calais a publié fin 2014 un ''{{Citation|État des lieux de la biodiversité dans les territoires des Schémas de cohérence territoriale}}''&lt;ref&gt;L’Observatoire de la biodiversité du Nord - Pas-de-Calais ; [http://www.observatoire-biodiversite-npdc.fr/fichiers/documents/biodiversite-dans-les-scot-orb-npdc-2014-light.pdf ''État des lieux de la biodiversité dans les territoires des Schémas de cohérence territoriale (SCoT)''], PDF, 300p) , 2014 &lt;/ref&gt; librement consultable et utilisable par les habitants et collectivités pour mieux repérer les [[w:fr:enjeu|enjeux]] locaux de biodiversité.

=== L'approche écosystémique ===
Elle relève des sciences de la complexité et fonde l'approche écologique. Elle ne semble jamais avoir clairement et profondément guidé l'ensemble d'un projet urbain ou architectural, même si l'on parle parfois d'écosystème urbain et souvent d'écologie urbaine. 
&lt;br /&gt;L'architecte et l'urbaniste n'en étant  pas coutumiers, ils pourront utilement s'adjoindre les services d'écologues compétents.

La ville ou d'autres milieux construits peuvent être considérés comme un écosystème unique ou comme une mosaïque d'écosystèmes plus ou moins artificialisés (vision pratique pour étudier, décrire et gérer la nature en ville&lt;ref&gt;Mission Économie de la biodiversité '''''[http://www.mission-economie-biodiversite.com/downloads/Cahier_n5_Comprendre_ville Infrastructures vertes urbaines et développement : vers une évaluation des impacts socio-économiques de la nature en ville]''''' ; Cahier n°5 de la collection &quot;Cahiers Biodiv'2050&quot;. &lt;/ref&gt;, à condition d'aussi bien comprendre les liens qui unissent ces milieux particuliers aux écosystèmes périphériques qui leur sont fonctionnellement reliés (via des corridors biologiques ou couloirs migratoires notamment). Bolund et Hunhammar ont proposé en 1999 sept catégories d' « ''écosystèmes urbains naturels'' » (qu'on pourra encore subdiviser en sous-unités)&lt;ref&gt;Bolund, P., Hunhammar, S. (1999), ''Ecosystem services in urban areas'', Ecological Economics, 29 (2), p. 293-301.&lt;/ref&gt;.

===La renaturation===
Cette notion évoque un certain retour ou une certaine acceptation des processus naturels, auto-entretenus, et donc du &quot;sauvage&quot;, nécessaire pour une ''« naturalité »'' plus élevée (et donc des équilibres écologiques moins perturbés).

===La notion de ''« qualité environnementale »'' ===
Elle couvre un domaine bien plus large que celui de la biodiversité, mais l'oubliant trop souvent. 
En France, on la résume souvent aux 14 cibles de la HQE, certains proposant depuis quelques années une quinzième cible (pour l'instant volontaire) et plus spécifiquement consacrée à la biodiversité.

===Le &quot;Zéro impact&quot;===
[[File:3x3rondMesuresCompensatoires.jpg|thumb|350px|Diagramme présentant quelques mots-clé et les relations et interrelations entre 3 modes de compensation d'impacts écologiques, tels que devant ou pouvant être compensés suite aux études d'impacts]]
[[File:Palmanova dal satellite 2004.jpg|thumb|250px|Le bâti ancien, militaire et fortifié notamment (ici la citadelle de Palmanova en Italie), peut abriter une biodiversité significative (y compris en terme génétique), qu'il conviendrait de protéger au même titre que le patrimoine bâti, ce qui demande aux architectes du patrimoine de travailler avec des écologues, et inversement afin de trouver les compromis les plus intéressant. C'est ce qui est fait à Lille pour la Citadelle de Vauban]]

C'est une &quot;cible&quot;, un but qu'on cherche à atteindre, notamment par des mesures d'atténuation et de réparation des impacts, visant :
* la diminution de l’empreinte écologique (et donc énergétique) du bâti ; c'est une approche globale prenant mieux en compte une partie des impacts initiés ou différés dans l'espace et le temps
* la diminution de l’impact écologique du bâti lui-même et de son fonctionnement (chauffage, ventilation, circulation, réseaux..)
* la diminution de l’impact écologique des occupants (y compris via une gestion, et un fonctionnement moins nuisants pour l'environnement) 
Ceci peut se faire en combinant trois grands types de mesures ou approches 
* des mesures conservatoires, 
* des mesures compensatoires (en cherchant à appliquer le principe de &quot;juste compensation&quot;)
* des mesures restauratoires
Ou, quand une restauration totale n'est pas possible (ce qui est souvent le cas) par le double principe de ''« restauration d'habitats » (génie écologique)'' et d'offre d' ''« habitats de substitution »'' (une mare alimentée par les eaux de gouttières, un nichoir intégré dans mur, une terrasse ou mur végétalisé  par exemple)
…pour répondre aux critères de &quot;Haute qualité&quot;, ces mesures doivent être &quot;justes, réelles, fonctionnelles et efficaces &quot; (&quot;Juste&quot; signifie ici qu'on cherche à restaurer l'écopotentiel du site et donc les fonctionnalités écologiques qui devraient normalement s'exprimer dans la zone biogéographique considérée, en l'absence d'impacts des activités humaines, ce qui implique une approche préalable de type &quot;étude d'impact&quot;, rigoureuse et intégrant les  aspects quantitatifs  et qualitatifs de la biodiversité) ; 

&lt;br /&gt;Ces approches sont théoriquement aussi celles des méthodes développées pour les études d'impacts qui peuvent – en amont – inspirer l'architecte et l'urbaniste, de même que les techniques et outils d'écobilan et d'ACV (Analyse du cycle de vie).

Le zéro impact ne peut généralement pas être atteint directement, il appelle donc une autre notion : celle de  &quot;Remboursement de la dette écologique&quot; ; c’est une cible et une exigence, dont nous ignorons si elle peut vraiment être tout à fait atteinte, notamment parce que c'est une notion relative au degré d'exigence du porteur de projet (quelle niveau de qualité environnementale cherchera-t-on à retrouver ?).  Cette  cible serait théoriquement  atteinte (100 points sur 100) quand la biodiversité peut s’exprimer sur le bâti et son environnement proche, comme elle le ferait dans une &quot;nature sauvage&quot; (où l’influence humaine ne se ferait pas sentir). Les indicateurs utilisables sont la &quot;biomasse équivalente&quot;, la &quot;diversité spécifique&quot;, une diversité &quot;génétique supposée comparable&quot;, etc).

====Le concept de bâti (ou construction) ''« à biodiversité positive »''. ====
Il prolonge la cible précédente. C'est un des moyens de rembourser une dette écologique en matière de biodiversité. &lt;br /&gt;Des indicateurs de réalisation objectifs et validés manquent encore pour cette cible (en partie théorique) mais elle est très motivante et offre d'intéressants défis à relever pour les architectes, urbanistes et usagers du patrimoine bâti.

===La gouvernance===
Dans le domaine de la biodiversité urbaine ou intégrée dans le bâti, l'expérience a montré qu'une grande partie des projets réussis sur le long terme se sont tous appuyés sur une gouvernance s'appuyant sur les principes d' ''« écocitoyenneté »'', et de ''« participation (&quot;proactive&quot; dans la mesure du possible) des parties prenantes »'' ; c'est un des facteurs de réussite sur le moyen et long terme. 

===L'évaluation===
Des  indicateurs d'état, de pression, d'impacts, de réponse ; quantitatifs et qualitatif, sont utiles et nécessaires pour le suivi et l'évaluation des projets, et pour affiner et améliorer les stratégies décrites dans cet ouvrage. 

De tels indicateurs peuvent être notamment fournis par 
* des dispositifs automatiques d'acquisition de données environnementales (réseau d'alerte et de mesure de la qualité de l'eau, de l'air, des sols, etc), mesures satellitales des surfaces &quot;naturelles&quot; et de leur connectivité écologique ou degré de fragmentation écopaysagère ;
* des études spécifiques, 
* un observatoire collaboratif de la biodiversité, 
* des sentinelles de l’environnement
* des écogardes, ou autres corps spécialisés dans le suivi ou la protecion de l'environnement
* La bio-indication (outil encore peu utilisé mais disponible). Elle peut être sophistiquée ou grossière mais efficace (ex : présence/absence de papillons, abeilles, hirondelles, moineaux, anguilles, brochet, saumons, vers de terre, etc… ou présence/absence d'espèces invasives ou indicatrices de déséquilibres écologiques)
* etc.. 

Les évaluateurs devraient chercher à mieux prendre en compte le cycle du vivant, dont la ''« nécromasse »'' et son recyclage.

== Notes et références ==
{{Références|colonnes=2}}

[[Catégorie:Introduire la biodiversité dans la construction et l'urbanisme (livre)|Préalables ; principes généraux et transversaux]]</text>
      <sha1>lftpg6slegwc6rn677evtwx4ao2uqw2</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation JavaScript/Programmer en deux minutes</title>
    <ns>0</ns>
    <id>33468</id>
    <revision>
      <id>684239</id>
      <parentid>635260</parentid>
      <timestamp>2022-08-27T12:52:59Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4073" xml:space="preserve">&lt;noinclude&gt;{{Programmation JavaScript}}&lt;/noinclude&gt;
JavaScript est un langage exécuté par le navigateur web, à l'affichage d'une page web. (il est surtout utilisé pour ça)

Créer ce document HTML (le nom du fichier se terminera généralement par '''&lt;code&gt;.html&lt;/code&gt;''') puis l'ouvrir avec un navigateur.

&lt;syntaxhighlight lang=html4strict&gt;
&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD HTML 4.01//EN&quot; &quot;http://www.w3.org/TR/html4/strict.dtd&quot;&gt;
&lt;html&gt; 
   &lt;head&gt;
      &lt;script type=&quot;text/javascript&quot;&gt;

          alert(prompt(&quot;bonjour le monde !&quot;));

      &lt;/script&gt;
   &lt;/head&gt;

   &lt;body&gt;
      Corps de la page.
   &lt;/body&gt; 
&lt;/html&gt;
&lt;/syntaxhighlight&gt;
Le navigateur vous demande d’entrer un texte dans une [[wikt:pop-up|pop-up]], affiche le texte donné dans une seconde [[wikt:pop-up|pop-up]], et enfin affiche le corps du document. '''Félicitations''', vous avez écrit vos premières instructions JavaScript dans un document HTML !

Note : La plupart des navigateurs exécuteront sans problème ce code simplifié :

&lt;syntaxhighlight lang=html4strict&gt;
&lt;body&gt;
   Corps de la page.
   &lt;script type=&quot;text/javascript&quot;&gt;
          alert(prompt(&quot;bonjour le monde !&quot;));
   &lt;/script&gt;
&lt;/body&gt;
&lt;/syntaxhighlight&gt;

==Une minute==
:Une page web est un document composé d'une tête et d'un corps (&lt;code&gt;&lt;html&gt; &lt;head&gt;&lt;/head&gt; &lt;body&gt;&lt;/body&gt; &lt;/html&gt;&lt;/code&gt;). 
:Le corps du document est affiché à l'écran tandis que la tête contient le titre de la page, son favicon, ses mots-clés, etc. (pour un exemple, afficher le code source de cette page (on peut souvent utiliser le raccourci clavier ''Ctrl + U''))
La tête comme le corps d'un document HTML peuvent contenir des instructions JavaScript :

&lt;syntaxhighlight lang=html4strict&gt;
&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD HTML 4.01//EN&quot; &quot;http://www.w3.org/TR/html4/strict.dtd&quot;&gt;
&lt;html&gt; 
   &lt;head&gt;
   &lt;/head&gt;
 
   &lt;body&gt;
      Corps.
   
      &lt;script type=&quot;text/javascript&quot;&gt;
          alert(prompt(&quot;bonjour le monde !&quot;));
      &lt;/script&gt;
   &lt;/body&gt; 
&lt;/html&gt;
&lt;/syntaxhighlight&gt;

Le navigateur se comporte comme pour le premier document de cette page, excepté le fait que le contenu de la page est affiché avant l’ouverture des [[wikt:pop-up|pop-up]]s

==une minute trente : une fonction JavaScript==

&lt;syntaxhighlight lang=html4strict&gt;
&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD HTML 4.01//EN&quot; &quot;http://www.w3.org/TR/html4/strict.dtd&quot;&gt;
&lt;html&gt; 
   &lt;head&gt;
      &lt;script type=&quot;text/javascript&quot;&gt;
          function Prompt_et_alert() {
               alert(prompt(&quot;bonjour le monde !&quot;));
          }
      &lt;/script&gt;
   &lt;/head&gt;
 
   &lt;body&gt;
      &lt;a onmouseout=&quot;Prompt_et_alert();&quot;&gt; &lt;!-- une ancre balise un hyperlien --&gt;
      Corps.
      &lt;/a&gt;

   &lt;/body&gt; 
&lt;/html&gt;
&lt;/syntaxhighlight&gt;

La fonction est définie en tête de document et est exécutée lorsque la souris sort de l'ancre (&lt;code&gt;onmouseout&lt;/code&gt;).

==deux minutes==
Afin d'aller plus loin, munissez votre navigateur d'un outil tel [[w:Firebug|Firebug]].

Pour apprendre à manipuler cet outil, introduisez une erreur dans votre document, par exemple en oubliant un des guillemets &lt;code&gt;&quot;&lt;/code&gt;, et vérifiez la présence de l'erreur dans la console JavaScript.

'''Félicitation''', vous êtes paré pour écrire davantage d'instructions !

En deux minutes :
# [[/Une page wiki|Une page wiki]] 
# [[/Compteur en temps réel|Compteur en temps réel]] des dépenses militaires.
# [[/Tout un site web dans un seul document|Tout un site web dans un seul document]].
# [[/Neige dans la fenêtre du navigateur|Neige dans la fenêtre du navigateur]].

== console.log() ==
Par la suite, nous utiliserons cette instruction pour faire apparaitre des messages en console, ce qui est pratique pour débuguer sans impacter le fonctionner du site (contrairement à &lt;code&gt;alert()&lt;/code&gt;). De plus, on peut y utiliser du code CSS et même y publier des tableaux.

== Voir aussi ==
* https://jsfiddle.net/ : un interpréteur en ligne, pratique pour tester des commandes.

&lt;noinclude&gt;
::''Voir aussi le livre : [[Programmer en deux minutes]]''.
[[Catégorie:Programmer en deux minutes (livre)|J]]
&lt;/noinclude&gt;</text>
      <sha1>e4rzqzr8u4bbq51malqyl5hdl69invw</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Web/Programmer en deux minutes</title>
    <ns>0</ns>
    <id>33488</id>
    <revision>
      <id>684240</id>
      <parentid>635809</parentid>
      <timestamp>2022-08-27T12:53:05Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5790" xml:space="preserve">Un site web est un ensemble de pages web envoyées par un serveur distant à votre navigateur.
:Une page web est un document html composé d'une tête et d'un corps (&lt;code&gt;&lt;html&gt; &lt;head&gt;&lt;/head&gt; &lt;body&gt;&lt;/body&gt; &lt;/html&gt;&lt;/code&gt;). La tête contient des informations telles le titre du document (&lt;title&gt;), son apparence (&lt;style&gt;) et ses animations (&lt;script&gt;) ; tandis que le corps du document est affiché.


Créer ce document HTML dans un éditeur de texte avec coloration syntaxique. L'enregistrer ('''&lt;code&gt;*.html&lt;/code&gt;''') puis l'ouvrir avec un navigateur :

&lt;syntaxhighlight lang=html4strict&gt;
&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD HTML 4.01//EN&quot; &quot;http://www.w3.org/TR/html4/strict.dtd&quot;&gt;
&lt;html&gt; 

   &lt;head&gt;
      &lt;title&gt;Page web&lt;/title&gt;

      &lt;script type=&quot;text/javascript&quot;&gt;
          alert(&quot;bonjour le monde !&quot;);
      &lt;/script&gt;

      &lt;style type=&quot;text/css&quot;&gt; 
          body { 
              background: green; 
            } 
          #division_une {
              border:1px dotted red;
              background: white; 
            }
      &lt;/style&gt;

   &lt;/head&gt;

   &lt;body&gt;
      Corps.

      &lt;div id=&quot;division_une&quot;&gt;
          Première division du corps.
      &lt;/div&gt;

      &lt;div id=&quot;division_deux&quot;&gt;
          Seconde &lt;a href=&quot;http://wikipedia.org&quot;&gt; &lt;!-- une ancre balise un hyperlien --&gt;
                   division 
                  &lt;/a&gt;
          du corps.
      &lt;/div&gt;
   &lt;/body&gt; 

&lt;/html&gt;
&lt;/syntaxhighlight&gt;
Le navigateur affiche le titre du document, alerte l'utilisateur, puis affiche le corps du document selon l'apparence déclarée. '''Félicitation''', vous avez écrit votre premier document HTML, contenant des déclarations de style CSS et des instructions JavaScript&lt;ref&gt;
(JavaScript est un langage exécuté par le navigateur à l'affichage d'une page web, du moins il est surtout utilisé pour ça)
&lt;/ref&gt; ! 


Vous pouvez partager ce document sur Internet, pour cela il vous faut un serveur, c'est-à-dire un logiciel qui &quot;sert&quot; les documents aux requêtes des visiteurs.

Votre ordinateur peut héberger votre serveur, ou vous pouvez utiliser un ordinateur distant. Il vous faut installer un serveur tel Apache ou nginx et l'exécuter. Un répertoire &lt;code&gt;/public_html&lt;/code&gt; est alors servi par le logiciel lors de la requête http://votre_adresse_IP depuis Internet et http://localhost depuis votre ordinateur.


&lt;references/&gt;

==L'index de votre site web==
Disposez d'un serveur, c'est-à-dire d'un répertoire &lt;code&gt;/public_html&lt;/code&gt; servi lors de requête http à votre ordinateur (distant ou local). 

Créez un document ('''&lt;code&gt;index.html&lt;/code&gt;''') dans le répertoire &lt;code&gt;/public_html&lt;/code&gt; et faites une requête http au serveur (via votre navigateur) : l'index du site est servi.


Si votre document est accessible sur Internet, vous pouvez le faire contrôler par le [http://validator.w3.org validator du w3c].

==Programmer côté serveur==
Renommez votre fichier ('''&lt;code&gt;*.html&lt;/code&gt;''') en ('''&lt;code&gt;*.php&lt;/code&gt;''') et ajoutez des instructions [[w:PHP|PHP - Hypertext Preprocessor]], exécutées par le serveur et délivrant un document html.

&lt;syntaxhighlight lang=php&gt;
&lt;? php

$titre=&quot;Titre du document&quot;; 
$alerte=&quot;bonjour le monde !&quot;; //l'alerte affichée entre les deux divisions du corps.

$msg=$_GET['msg'];
if (!isset($msg)) {$msg=&quot;Message par défaut.&quot;}

?&gt;&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD HTML 4.01//EN&quot; &quot;http://www.w3.org/TR/html4/strict.dtd&quot;&gt;
&lt;html&gt; 

   &lt;head&gt;
      &lt;title&gt;&lt;?php echo $titre; ?&gt;&lt;/title&gt;

      &lt;script type=&quot;text/javascript&quot;&gt;
          function Prompt_et_alerte() {
               alert(prompt(&quot;Votre souris est sortie de l'ancre !&quot;));
          }
      &lt;/script&gt; 

      &lt;style type=&quot;text/css&quot;&gt; 
          body { 
              background: green; 
            } 
          #division_une {
              border:1px dotted red;
              background: white; 
            }
      &lt;/style&gt;

   &lt;/head&gt;

   &lt;body&gt;

      &lt;div id=&quot;division_une&quot;&gt;
          Première division du corps. &lt;?php echo $msg; ?&gt;
      &lt;/div&gt;   
     
      &lt;script type=&quot;text/javascript&quot;&gt;
          alert(&lt;?php echo $alerte; ?&gt;);
      &lt;/script&gt;

      &lt;div id=&quot;division_deux&quot;&gt;
          Seconde &lt;a href=&quot;http://wikipedia.org&quot; onmouseout=&quot;Prompt_et_alerte();&quot;&gt; &lt;!-- la fonction Javascript est exécutée lorsque la souris sort de l'ancre --&gt;
                   division 
                  &lt;/a&gt;
          du corps.
      &lt;/div&gt;
   &lt;/body&gt; 

&lt;/html&gt;
&lt;/syntaxhighlight&gt;

Faites une requêtes au serveur et lisez le code source (ctrl+U) de la page html servie.

Le PHP a été interprété par le serveur, le navigateur affiche la page html résultante.

Essayez la requête http://yourhost/index.php?msg=mon_message : le serveur affiche votre message dans le corps du document html.

==Aller plus loin==
Afin d'aller plus loin, munissez votre navigateur d'un outil tel [[w:Firebug|Firebug]].

Pour apprendre à manipuler cet outil, introduisez dans votre document plein de divisions et de déclarations de style associées, éventuellement des erreurs JavaScript, et vérifiez que vous savez utiliser l'outil pour retrouver l'identifiant et le style des divisions html, ainsi que les erreurs d'exécution JavaScript.

'''Félicitation''', vous êtes paré pour enrichir votre site web de fichiers HTML, CSS, JavaScript et PHP !


Pour aller plus loin :
*[[Programmation JavaScript/Programmer en deux minutes/Tout un site web dans un seul document|Tout un site web dans un seul document]] HTML grâce à JavaScript.
*[[/Un wiki en JavaScript et PHP]].
*[[/Un site web avec trois fichiers et une base de donnée]]. (une base de donnée MySQL, un fichier .php, un .js et un .css)


::''Voir aussi le livre : [[Programmer en deux minutes]].''

[[Catégorie:Programmation JavaScript (livre)]]
[[Catégorie:Programmer en deux minutes (livre)|W]]</text>
      <sha1>pgpy1du6yms83xe2smnrg735vtor64o</sha1>
    </revision>
  </page>
  <page>
    <title>Histoire populaire de France/Intrigue</title>
    <ns>0</ns>
    <id>34533</id>
    <revision>
      <id>684312</id>
      <parentid>660359</parentid>
      <timestamp>2022-08-27T18:51:21Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4947" xml:space="preserve">:''N'hésitez pas à améliorer l'intrigue.''

==Chronologie==
====du XIIIième au XVIIième siècle====
*Massacre des Cathares
* {{w|Révolte des Karls}} - 1323 - 1328
* {{w|Jacqueries}} - 1358 - 1700
* Le Code Noir - 1685

====XVIIIième siècle====

1740
* Les Canuts lyonnais - 1744 à 1790
*:''Références :'' [http://rebellyon.info/Le-5-mai-1790-les-canuts-decident.html]

1770
*{{w|Guerre des farines}}

1780
*{{w|Révolution française}} - 1789

====XIXième siècle====
*Napoléon rétablit l'esclavage en Guadeloupe - 1802 

* {{w|Révolte des Canuts}} - 1830
*{{w|Saint-Arnaud}} arrive en Algérie - 1837

*fusillade du Brûlé. le 16 juin 1869

1870
*Guerre franco-allemande de 1870 - 1871
*:''Caractère :'' {{w|Michel Bakounine}}
* {{w|La Commune}} Lyon 1870 - Paris 1871
*:''Caractères:'' {{w|Louis Auguste Blanqui}}, {{w|Ravachol}}
*{{w|Orphelinat de Cempuis}}

1880
*Procès des 66 anarchistes - 1883
*:''Références :'' [http://rebellyon.info/Declaration-des-66-Anarchistes-au.html]
*:''Caractères:'' {{w|Pierre Kropotkine}}

1890
*{{w|Fête du Travail}} le 1er mai pour les huit heures - 1891
*la fusillade de Fourmies - 1891
*Les {{w|lois scélérates}} - 1893

====XXième siècle====

1900
*Grèves d’Armentières - 1903
*:''Références :'' [http://rebellyon.info/Emeutes-d-Armentieres-en-1903-le.html]
*{{w|Révolte des vignerons du Languedoc en 1907}}

1910
*Grève des boutonnières de l'Oise [http://volunteer.indymedia.org/La-greve-des-boutonniers-de-l-Oise.html]

Guerre 14 - 18. Soldat des colonies.
*{{w|Accords Sykes-Picot}} - 1916
*{{w|Grèves de juin 1919}}

1920
*{{w|Grèves en 1920}}

1930
*{{w|synarchie}} (''Le Choix de la défaite : les élites françaises dans les années 1930'' d'{{w|Annie Lacroix-Riz}}.
*{{w|Front populaire (France)}}
*:''Caractères :'' {{w|Deux cents familles}}
Guerre 39 - 45

1940
* Collaboration de la police à la {{w|Rafle du Vélodrome d'Hiver}} - 1942
*:''Caractères :'' {{w|Pétain}}
*résistance au STO 1942 [http://volunteer.indymedia.org/Octobre-lyonnais-en-1942-Pas-un.html]
* Le {{w|Conseil national de la Résistance}} et son programme - 1943
*:''Anecdote :'' Appel des Résistants en 2004
* Un faux journal &quot;Le Nouvelliste&quot; - 1943
*:''Références :'' [http://rebellyon.info/Un-faux-journal-Le-Nouvelliste.html]
*:''Anecdote :'' le NY Times des {{w|The Yes Men}} en 2008.
*Massacre du Camp de Thiaroye 1944 [http://rebellyon.info/A-Thiaroye-en-decembre-1944-la.html]
*8 Mai 1945 : Massacre de Sétif
{{w|Guerre d'Indochine}} 46 - 54
::''Réf:'' [http://quefaire.lautre.net/ancien/articles/05indochine.html refractaires]

1950
* Arrêt Dehaene du Conseil d'État (confirme que le droit de grève a le statut de principe fondamental) - 1950
* Hivers 54
*:''Caractères :'' {{w|Abbé Pierre}}

{{w|Guerre d'Algérie}} 54 - 62
*:''Caractères :'' {{w|Michel Pablo}}
*:''Anecdotes :'' argent public versé au FLN [http://www.jp-petit.org/Presse/camp_des_assassins.htm]
*:''Références :'' [http://www.refractairesnonviolentsalgerie1959a63.org/ réfractaires]
1960
*{{w|Massacre du 17 octobre 1961}}
*:''Caractères :'' {{w|Maurice Papon}}, {{w|Alexis Violet}}
*:massacres au Cameroun - 1960 [http://volunteer.indymedia.org/2-mars-1960-massacres-au-Cameroun.html]
*{{w|Ben Barka}} [http://volunteer.indymedia.org/Mehdi-Ben-Barka-assassine-le-29.html]
*{{w|mai 68}}

1970
*manifeste des 343 salopes - 5 avril 1971
* {{w|Larzac}} - 1971
*:''Caractères :'' {{w|José Bové}}
*:''Anecdotes :'' création de {{w|Biocoop}} en 1986.
* {{w|Lip}} - 1973
* Affaire Chapron - 1975
*:''Références :'' [http://syndicat-magistrature.org/spip.php?article856]
*:''Caractères :'' {{w|Patrice de Charette}}
*:''Anecdotes :'' [http://volunteer.indymedia.org/Penarroya-les-travailleurs.html]
*{{w|La Nef (coopérative)}} - 1979 1988
*:''Anecdotes :'' création d'{{w|Enercoop}} en 2005.

1980 
*{{w|Gladio}}

* Candidature du &quot;clown&quot; - 1981
*:''Caractères :'' {{w|Coluche}}
* «{{w|La Marche de l’égalité}} » dite « {{w|Marche des beurs}} » - 1983
*{{w|Affaire du Rainbow Warrior}} - 1985
*Revolution au Burkina
*:''Caractères :'' {{w|Thomas Sankara}}
*:''Anecdote :'' {{w|Patrice Lumumba}}
1990
* {{w|Grèves de 1995 en France}}
*:''Caractères :'' {{w|Pierre Bourdieu}}
* {{w|Appel de Genève}}
*:''Caractères :'' {{w|Denis Robert}}
* {{w|Guerre du Kosovo}} - 1999
* {{w|emploi fictif}} et {{w|financement occulte}} des partis politiques

====XXIième siècle====
*Attentat du WTC
*:''Caractères :'' {{w|Thierry Meyssan}}
*Attentat de Karachi [http://www.verite-attentat-karachi.org/] - 2002
*Révolte des banlieues - 2005
*:''Anecdote :'' {{w|ACLEFEU}} et le &quot;cahier des doléances&quot;
*{{w|Affaire de l'UIMM}} - 2007 (des fonds occultes pour casser les grévistes)
*Guerre en Afghanistan - 2008

==Références pour enrichir l'intrigue==
*{{w|Grève en France}}
*{{w|Liste de révolutions et de rébellions}}

[[Catégorie:Histoire populaire de France (livre)|Intrigue]]</text>
      <sha1>gah7sq22h4074ijram0dq9iwx3tmit7</sha1>
    </revision>
  </page>
  <page>
    <title>Livre des abréviations des francophones/Par domaines/Termes de téléphonie</title>
    <ns>0</ns>
    <id>38908</id>
    <revision>
      <id>684263</id>
      <parentid>641822</parentid>
      <timestamp>2022-08-27T18:06:51Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="11822" xml:space="preserve">La page des '''termes de la téléphonie du livre des abréviations des francophones''' donne la forme développée d'abréviations utilisées par les francophones pour parler de la téléphonie. Les francophones utilisant des termes autres que français, certaines abréviations ne sont pas françaises. Par exemple, nombre d'entre elles sont en anglais parce que cette langue est très utilisée en téléphonie.

{{SommaireCompact}}

== Chiffre ==
* 2G : Deuxième génération
* 3G : Troisième génération
* 3GPP : 3rd Generation Partnership Project
* 4G : Quatrième génération

== A ==
* ADM : Add/Drop Multiplexer&lt;ref name=&quot;Iliad&quot;&gt;[http://www.iliad.fr/glossaire.html www.iliad.fr]&lt;/ref&gt; 
* ADSL : Asymetric Digital Suscriber Line (''Ligne d'abonné numérique asynchrone'')&lt;ref name=&quot;www.dicofr.com&quot;&gt;[http://www.dicofr.com www.dicofr.com/]&lt;/ref&gt;
* AFNIC : Association française pour le nommage Internet en coopération&lt;ref name=&quot;Iliad&quot;/&gt;
* AMRC large bande : AMRC large bande
* AOL : America Online
* API : Application and Programming Interface (''Interface pour la programmation d'applications'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* ARCEP : Autorité de régulation des communications électroniques et des postes
* ART : Autorité de régulation des télécommunications
* ASIM : Automated Security Incident Measurement
* ASM : Automated Security Monitoring
* ATM : Asynchronous Transfer Mode (''Mode de transfert asynchrone'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* AS : Application Server

== B ==
* BIT : Binary Digit&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* BPL : Broadband over PowerLine
* BPM : Beat Per Minute (''Battement à la minute'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* BPS : Bits par seconde&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* BPSK : Binary Phase-Shift Keying
* BCRCI : Brigade centrale de répression du crime informatique

== C ==
* CAA : Commutateur à autonomie d'acheminement&lt;ref name=&quot;Iliad&quot;/&gt;
* CDMA : Code Division Multiple Access&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* CERTA : Centre d'expertise gouvernemental traitant les attaques informatique
* CGI : Common Gateway Interface (''Interface passerelle commune'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* CCITT : Consultative Committee for International Telephony and Telegraphy (''Comité consultatif pour la téléphonie et le télégraphe internationaux'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* CNRS : Centre national de recherche scientifique&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* Codec : Compression-décompression, ou Codage-décodage ou COde-DECode
* CPL : Courants porteurs en ligne
* CPS : Caractères par seconde
* CSCF : Call Session Control Function
* CSTA : Computer Supported Telecommunication Application&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* CT : Centre de transit&lt;ref name=&quot;Iliad&quot;/&gt;
* CTI : Couplage téléphonie informatique

== D ==
* DAS : Degré d'absorption spécifique
* DECT : Digital European Cordless Telephone
* DMZ : DeMilitarized Zone (''Zone DéMilitarisée'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* DPSK : Differential Phase-Shift Keying
* DSL : Digital Subscriber Line (''ligne numérique d'abonné'')
* DSLAM : Digital subscriber line access multiplexer
* DTMF : Dual Tone Multi Frequency

== E ==
* EDGE : Enhanced Data Rate for GSM Evolution
* EFR : Enhanced Full Rate (''Plein débit amélioré'')
* ECMA : European Computer Manufacturers Association&lt;ref name=&quot;www.dicofr.com&quot;/&gt;

== F ==
* FAI : Fournisseur d’accès à internet
* FM : Frequency modulation (''Modulation de fréquence'')
* FON : Fibre optique noire&lt;ref name=&quot;Iliad&quot;/&gt;
* FT : France Télécom
* FTP : File Transfer Protocol (''Protocole de transfert de fichiers'')

== G ==
* GPRS : General Packet Radio Service
* GPS :Global Positioning System (''Système de positionnement global'')
* GSM : Global System for Mobile Communications (''Groupe spécial de mobiles'')
* GSMA : GSM Association (''Association GSM'')

== H ==
* HDMI :High-Definition Multimédia Interface (''Interface multimedia haute définition'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* HDML : Handheld Device Markup Language
* HSCSD : High Speed Circuit Switched Data
* HTC : High Tech Computer Corporation
* HTML : HyperText Markup Language&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* HTTP : HyperText Transfer Protocol&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* HSDPA : High Speed Downlink Package Access&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* HSS : Home Subsciber Server

== I ==
* I-CSCF : Interrogating CSCF
* IAX : Inter-Asterisk eXchange (''Commutation inter-Astérisk'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* IAB : Internet Architecture Board
* IBM : International Business Machines Corporation
* IEEE : Institute of Electrical and Electronics Engineers (''Institut des ingénieurs en électricité et en électronique'')
* IETF : Internet Engineering Task Force
* IMEI : International Mobile Equipment Identity
* i-mode : information-Mode&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* IMS : IP Multimedia Subsystem
* IP : Internet Protocol (''Protocole de l'internet'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* IPsec : Internet Protocol Security&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* IPv4 : Internet Protocol version 4&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* IPv6 : Internet Protocol version 6&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* IrDA : InfraRed Device Association
* ISDN : Integrated Service Digital Network (''Réseau Numérique à Intégration de Services'')
* ISL : Cisco Inter-Switch Link (''Liaison inter commutateurs Cisco'')
* ISEG : Internet Engineering Steering Group
* ISOC : Internet Society
* ITU : International Telecommunication Union (''Union internationale des télécommunications'')
* IVR : Interactive Voice Response

== J ==

== K==

== L ==
* LAN : Local Area Network (''Réseau local''')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* LDP : Label Distribution Protocol&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* LTE : Long Term Evolution (''Évolution à long terme'')
* LS : Ligne spécialisée

== M ==
* MCDU : Millier Centaine Dizaine Unité
* MG : Media Gateway
* MGCF : Media Gateway Control Function
* MIA : Module d'identification d'abonné
* MIB : Management Information Base (''Base d'information pour la gestion du réseau'')
* MIC : Modulation d'impulsion codée
* MIMO : Multiple-Input Multiple-Output (''Entrées multiples, sorties multiples'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* MIT : Massachusetts Institute of Technology&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* MMS : Multimédia Messaging Service
* MPLS : Multiprotocol Label Switching
* MRF : Multimedia Ressource Functions
* MRFC : Media Resource Control Function
* MVNO : Mobile Virtual Network Operator&lt;ref name=&quot;www.dicofr.com&quot;/&gt;

== N ==
* NAS : Network Attached Storage&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* NDI : Numéro de désignation d'installation 
* NDS : Numéro de désignation secondaire
: Ni-Cad : Nickel Cadium&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* NiMH : Nickel Métal Hydrure
* NGN : New Generation Network (''Réseau de nouvelle génération'')

== O ==
* OSI : Open Systems Interconnection (''Interconnexion de systèmes ouverts'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* OTP : OneTime Password
* OTT : Over The Top

== P ==
* P-CSCF : Proxy Call Session Control Function&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* PABX : Private Automatic Branch Exchange (''Commutateur automatique privé'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* PBX : Private Branch eXchange (''Commutateur privé'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* PC : Personnal Computer (''Ordinateur personnel'')
* PCBX : PABX sur PC&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* PCM : Pulse Code Modulation (''Modulation d'impulsion codée'') 
* PDA : Personnal Digital Assistant&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* PIN : Personal Identification Number (''Numéro d'identification personnelle'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* Ping : Packet Internet Groper&lt;ref name=&quot;Iliad&quot;/&gt;
* PLC : Powerline Communications
* PLT : Powerline Telecommunication
* POP : Point de présence opérateur&lt;ref name=&quot;Iliad&quot;/&gt;
* PPC :
** PowerPC
** Power Plus Communications
* PRBT : Personal Ring Back Tone
* PSK : Phase-Shift Keying
* PSTN : Public Switched Telephone Network (''Réseau téléphonique public commuté'')
* PUK : Personal Unblocking Code (''Code de déblocage personnel'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;

== Q ==
*QAM : Quadrature Amplitude Modulation
* QoS : Quality Of Service (''Qualité de service'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* QPSK : Quadrature Phase-Shift Keying

== R ==
* RFC : Request For Comments
* RIO : Relevé d'identité opérateur
* RIP : Routing Information Protocol (''Protocole d'information de routage'')
* RLAN : Radio Local Area Network&lt;ref name=&quot;Iliad&quot;/&gt;
* RNIS : Réseau numérique à intégration de services
* RTC : Réseau téléphonique commuté
* RTCP : Réseau téléphonique commuté public

== S ==
* S-CSCF : Serving CSCF&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* SCS : Sociétés de commercialisation et de services
* SDA : Sélection directe à l'arrivée
* SDH : Synchronous Digital Hierarchy&lt;ref name=&quot;Iliad&quot;/&gt;
* SFR : Société française de radiotéléphonie
* SGSN : Serving GPRS Support Node
* SIM : Subscriber Identity Module (''Module d'identification d'abonné'')
* SIP : Session Initiation Protocol (''Protocole d'initiation d'une session'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* SMS : Short Message System (''Système de messages courts'')
* SNMP¨: Simple Network Management Protocol (''Protocole simplifié d'administration de réseau'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* SSH : Secure Shell (''Shell Sécurisé'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* SU : Service universel&lt;ref name=&quot;Iliad&quot;/&gt;
* SVI : Serveur vocal interactif

== T ==
* Tapi : Telephony Application Programing Interface&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* TCP : Transmission Control Protocol (''Protocole de contrôle de transmission'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* TDM : Time Division Multiplexing (''Multiplexage temporel'')
* Télécoms : Télécommunications
* Telnet : TErminal NETwork ou TELecommunication NETwork, ou encore TELetype NETwork
* TISPAN : Telecoms &amp; Internet converged Services &amp; Protocols for Advanced Networks
* TLD : Top Level Domain&lt;ref name=&quot;Iliad&quot;/&gt;
* ToIP : Telephony over Internet Protocol (''Téléphonie sur le protocole de l'internet'')

== U ==
* UIT : Union internationale des télécommunications&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* UHF : Ultra haute fréquence
* UMTS : Universal Mobile Telecommuniçcations System&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* URL : Uniform Resource Locator&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* URI : Uniform Resource Identifier&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* USB : Universal Serial Bus&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* USIM : Universal Subscriber Identity Module&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* UTP : Unshielded Twisted Pair (''Câble non blindé'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* URA : Unité de raccordement d'abonnés&lt;ref name=&quot;Iliad&quot;/&gt;

== V ==
* VHF : Très haute fréquence
* VLAN : Virtual Local Area Network (''Réseau local virtuel'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* VoDSL : Voix sur DSL&lt;ref name=&quot;Iliad&quot;/&gt;
* VoIP : Voice over Internet Protocole (''Voix sur le protocole de l'internet'')&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* VPN : Virtual Private Network (''réseau privé virtuel'')
* VoLTE : Voice over Long Term Evolution

== W ==
* Wap : Wireless Application Protocol (''Protocole d'application sans fil'')
* WCDMA : Wideband CDMA
* WebRTC : Web Real-Time Communication 
* Wid : Wireless Information Device
* Wi-Fi : Wireless Fidelity (''Qualité du sans-fil'')
* WiMAX : Worldwide Interoperability for Microwave Access
* Wlan : Wireless Local Area Network&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* Wpan : Wireless Personal Area Network&lt;ref name=&quot;www.dicofr.com&quot;/&gt;
* WWAN : Wireless Wide-Area Network&lt;ref name=&quot;www.dicofr.com&quot;/&gt;

== X ==

== Y ==

== Z ==
* ZT : Zone de transit&lt;ref name=&quot;Iliad&quot;/&gt;
* ZNE : Zone de numérotation élémentaire&lt;ref name=&quot;Iliad&quot;/&gt;
* ZTA : Zone de télécommunications avancées&lt;ref name=&quot;www.dicofr.com&quot;/&gt;

== Références ==
{{Références}}

[[Catégorie:Domaines du livre des abréviations des francophones (livre)|Téléphonie]]
[[Catégorie:Techniques|Abréviations]]</text>
      <sha1>hvrfm0mnvrcsj0bojlxalfk84rikhzg</sha1>
    </revision>
  </page>
  <page>
    <title>Mkdir</title>
    <ns>0</ns>
    <id>39880</id>
    <revision>
      <id>684265</id>
      <parentid>643834</parentid>
      <timestamp>2022-08-27T18:07:42Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="569" xml:space="preserve">{{Désambiguation}}

Mkdir ('''''M'''a'''k'''e '''dir'''ectory'') peut désigner :

* [[DOS/Mkdir|La commande mkdir du DOS]]
* [[Le système d'exploitation GNU-Linux/Commandes de base#mkdir (make directory)|La commande mkdir de Linux]]
* [[Programmation Bash/Interactions avec le système de fichiers#Création d'un répertoire|La commande mkdir de l'interpréteur bash]]
* [[Programmation Java/Entrées Sorties#Création|La méthode mkdir de la classe File de l'API du langage Java]]
* [[Programmation PHP/Fichiers#Écriture|La fonction mkdir de l'API du langage PHP]]</text>
      <sha1>ni2ctk7p70midxq6l9srsat0seqvmya</sha1>
    </revision>
  </page>
  <page>
    <title>Technologie/Matériaux/Matériaux biocompatibles/Le Rein, site d’implantation en Biocompatibilité</title>
    <ns>0</ns>
    <id>41197</id>
    <revision>
      <id>684288</id>
      <parentid>679314</parentid>
      <timestamp>2022-08-27T18:27:30Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="68050" xml:space="preserve">{{Matériaux biocompatibles}}


&lt;br /&gt;&lt;br /&gt;

&lt;div style=&quot;text-align: center;font-size:2.0em;&quot;&gt;'''Le Rein, site d’implantation en Biocompatibilité'''&lt;br/&gt;&lt;br /&gt;&lt;/div&gt;


&lt;br /&gt;&lt;br /&gt;


= Les auteurs =

* '''Souad Naim''', Docteur en Sciences odontologiques, Maître Assistante, Hôpital Militaire d’instruction Mohamed V, Rabat. Adresse privée : BP 8229, Rabat-Nations Unies, Agdal, Rabat, Maroc.

* '''Geneviève Grégoire''', Professeur des Universités, Laboratoire Interactions Biomatériaux/Tissus bucco-dentaires, Faculté de Chirurgie Dentaire, 3 chemin des Maraîchers, 31062 Toulouse-Cedex.

* '''[[Utilisateur:Aomar Allabouch|Aomar Allabouch]]''', Docteur en Sciences odontologiques, Professeur, Hôpital Militaire d’instruction Mohamed V, Rabat. Adresse privée : BP 8229, Rabat-Nations Unies, Agdal, Rabat, Maroc.

* '''Roger Salmon''', Professeur des Universités, Laboratoire de Chimie des Solides, CNRS, Université Bordeaux , Talence (33400), Tél. : 05 56 84 62 58. 

* '''Jacques Colat-Parros''', U.F.R. d’odontologie, 16 à 20 cours de la Marne 330000 Bordeaux.

* '''Jean-Marie Meunier''', Professeur des Universités Honoraire, 132 rue de Pessac,  33 000 Bordeaux, France. Tél. :05 56 96 60 00.


Suggestion pour les auteurs : Naim S. 1, Grégoire G. 2,  Allabouch A. 1, Salmon R. 3, Colat-Parros J. 4, Meunier J.M. 5.

= Résumés =

== En français ==

De nombreux sites d’implantation sont définis pour tester la biocompatibilité des matériaux utilisés en odontologie, ce travail propose le rein du rat : un site original par sa structure et sa situation. La zone sous capsulaire rénale juxtapose des éléments conjonctifs (capsule rénale) et des éléments épithéliaux (les tubes rénaux). On y trouve donc les deux types de structures histologiques existant dans la gencive.

La zone sous capsulaire rénale soulevée à l’aide d’une pince à griffes est incisée sur une longueur de x mm, au tiers supérieur de l’organe, dans sa région postérieure et dorsale. À l’aide  d’une spatule mousse, la capsule est décollée du parenchyme rénal jusqu’au niveau du tiers inférieur, sur une surface de y mm² (x et y dépendent de la nature et des dimensions de l’implant) ; dans l’espace ainsi délimité, on inclut l’implant. Les réactions entre les tissus et l’implant peuvent être appréciées au terme de l’expérimentation avec les techniques les plus précises.

Dans cette étude nous proposons un modèle biologique expérimental avec l’implantation d’implants en phosphate tricalcique sous la capsule du rein du rat pour une période allant de 1 à 6 mois. Le mode de préparation des implants et la technique chirurgicale sont exposés. L’étude histologique prouve que le phosphate tricalcique utilisé est biocompatible, biorésorbable et bioréactif. Ce travail nécessite des investigations supplémentaires utilisant d’autres animaux et un site osseux.   

== En anglais, abstract ==

A lot of sites are definite for testing dental materiel biocompatibility, this study purpose the kidney of rat. This site is original because of its situation and its structure. On the kidney, the adrenal gland is made off both connective (capsule) and epithelial structure (renal tubes), the same sort of structures which can be also find in genciva.

The adrenal gland is lifted, a x mm long incision made (on the upper third part and the back of dorsal part of the organ), then the capsule is unlined from the renal parenchyma to the lower third part. An area of about y mm2 is cleared on which the implant is inserted (x and y depend of implant nature and its measurements).The reaction between implant and tissues can be observed after the experimentations with the must precise technics.

We purpose a biological model experimental with the implantation of a tricalcium phosphate under kidney capsule of rat for up to one month to six month. In this study preparation of implant and surgical ethnic are exposed. The histological study improve that tricalcium phosphate used is biocompatible, bioresorbable and bioreactif. This study must be completed by other investigation using other animals and a bone site.    


= Introduction =

Pendant les dernières décennies, l'utilisation des matériaux implantés reposait sur des notions empiriques, trop souvent déduites d'échecs cliniques. De nos jours, l'utilisation d'un matériau n'est envisageable qu'après analyse des réponses à un certain nombre de tests normalisés ; si les notions physiques ont été la préoccupation majeure au départ, la biocompatibilité prend actuellement une place prépondérante et exige un certain nombre d'essais découlant de la complexité biologique (12, 14). Le concept de biocompatibilité oblige à un protocole expérimental. Cependant le coût élevé des différents tests a souvent contraint les auteurs à ne réaliser que des expérimentations in vitro (14). « À défaut de moyens, il faut faire des calculs », nous avons exploité cet adage pour proposer une expérimentation in vivo sur le rat albinos de souche Wistar. Nous avons choisi un site profond (la zone sous capsulaire rénale) pour étudier la tolérance tissulaire d'un phosphate tricalcique.

La justification du choix du rat albinos, de souche Wistar, sélectionné à partir d'une lignée consanguine, s’appuie sur la facilité d’entretien normalisé d’animaux sociables, joueurs et apprivoisés, de faible poids, capables de se reproduire rapidement en captivité dans des conditions parfaitement définies de température, d’humidité et d’éclairage.
La croissance continue de l’animal peut entraîner des déplacements de l’implant s’il est mis dans une zone labile, ce qui est le cas des muscles para-vertébraux. C’est pour cela que la zone sous capsulaire rénale a particulièrement retenu notre intérêt en raison de sa situation profonde, de son accès relativement aisé et de sa double structure épithélio-conjonctive comparable à celle que l’on trouve au niveau de la gencive.  

Notre étude vise à élaborer un modèle d’essai biologique in vivo au niveau de la zone sous capsulaire rénale du rat en vue d’étudier le comportement in vivo d’un produit destiné à la thérapeutique en chirurgie.

Dans ce travail, l'exposé de la technique utilisée précise :
* la préparation des implants de phosphate tricalcique ;
* le protocole opératoire d'implantation dans la zone sous capsulaire rénale ;
* les conditions de prélèvements après un, deux, trois et six mois ;
* la préparation, la coloration des coupes histologiques, l'interprétation des résultats.

Une question se pose : les réactions inflammatoires observées au niveau de ce site après implantation de biomatériaux pendant un mois (1), vont-elle persister ou bien laisser place à un site parfaitement cicatrisé ?


= La biocompatibilité =

== Définition ==

Il est bien difficile de définir la biocompatibilité du fait de sa complexité. Un biomatériau est qualifié de biocompatible quand sa mise en place n'a aucune conséquence néfaste pour le receveur, à court, à moyen et à long terme, et lorsqu'il  assure parfaitement le rôle qui lui est dévolu, sans perturber les fonctions des organes avec lesquels il est en relation (5).

Il faut distinguer la notion de bio-compatibilité de celle de « tolérance biologique ».

Il y a quelques années le Professeur Marcel Jozefowicz proposait de définir les biomatériaux comme des « matériaux appelés à travailler sous contrainte biologique » (5) (12).
La biocompatibilité est fonction non seulement de la nature constitutive des matériaux, mais encore de la géométrie de la pièce, de son état de surface et de ses caractéristiques physico-chimiques (5-12).

== Évolution du concept de biocompatibilité ==

Pendant longtemps, l'attitude dominante a été d'utiliser pour la confection de matériels implantables des matériaux initialement conçus pour d'autres applications.
Cette situation n'a pas pleinement satisfait les spécialistes qui préfèrent une véritable symbiose entre l'hôte et l'implant. Ils ont donc cherché des matériaux réellement biocompatibles, comme les matériaux de prothèses orthopédiques qui peuvent être colonisés par les cellules osseuses (5-12).

== Facteurs de bio-compatibilité liés au matériau ==

Les essais de bio-compatibilité doivent permettre d'évaluer la sécurité, l'efficacité et la durée de vie des matériaux. La servitude biologique soumet l'implant au vieillissement et à la dégradation ; il importe donc de veiller à ce que ses propriétés initiales ne soient pas altérées.

La bio-compatibilité est essentiellement liée au matériau, aux conditions de son utilisation et à son environnement immédiat (5). Cependant les variations des conditions physico-chimiques de l'environnement de l'implant peuvent faire varier cette propriété. L'exemple du pH salivaire est significatif à cet égard ; il joue un rôle très important dans la durée de vie d'un implant, les recherches menées par Sandhaus décèlent des salives acides et des salives alcalines. Toute pathologie au niveau d'une des glandes salivaires peut entraîner un changement de pH et par là même favoriser des réactions néfastes pour l’organisme.

== Les essais de biocompatibilité ==

=== Généralités ===

La composition chimique de l'implant joue un rôle essentiel dans son interaction avec les tissus. Elle doit être connue de façon la plus complète possible (5).
La prise en compte de la composition du matériau, des impuretés éventuelles ainsi que des produits de dégradation susceptibles de se former et d'être &quot;relargués&quot; est nécessaire à l'interprétation des résultats des essais biologiques (5). D'autres facteurs peuvent influencer l'interaction entre matériaux et tissus :
- l'importance de la surface relative du dispositif,
- la structure poreuse ou non du matériau,
- la forme géométrique,
- le caractère répétitif ou non du contact du tissu avec le même dispositif, etc.
Les essais de biocompatibilité ne sont proposés qu'en relation avec les objectifs poursuivis. Ils doivent tenir compte de l'utilisation clinique finale, du temps de contact et du site d'implantation (5)

=== Les divers essais (normes AFNOR) ===

- essai de cytocompatibilité,
- essai d'hémocompatibilité,
- pouvoir mutagène,
- test de toxicité générale,
- essai d'irritation de la peau,
- essai d'irritation de la muqueuse,
- essai de sensibilisation,
- essai d'implantation à court terme,
- essai d'implantation à long terme,
- pouvoir cancérigène,
- autres essais : risques viraux et immunologiques, etc.
Le coût élevé de la recherche &quot;in vivo&quot; et le temps de mise en œuvre obligent le plus souvent à limiter les essais &quot;in vitro&quot;(5). Les essais &quot;in vitro&quot; doivent toujours) être complétés par des essais &quot;in vivo&quot; (5)


= Matériel et méthode =

== Choix du matériau : le phosphate tricalcique ==

Le chirurgien est souvent confronté au traitement de pertes de substances osseuses, qu'elles soient d'origine congénitale, traumatique, orthopédique, infectieuse ou tumorale. Plusieurs matériaux sont disponibles. Le phosphate tricalcique connu pour ses propriétés de bio-réactivité (21), constitue un matériau de choix pour répondre aux besoins des praticiens, ses applications ont été nombreuses (28).

Le phosphate tricalcique convient pour le comblement des lésions osseuses, pour favoriser la réparation et l'induction tissulaire et pour le traitement de surface d'implants métalliques ou céramiques pour améliorer l'ancrage des matériels implantés.

Le phosphate tricalcique disparaît des lieux d'implantation par deux processus : biodégradation de la céramique par dissolution des joints de grains et bio-résorption des grains de la céramique. Il peut ainsi aider et induire la régénération tissulaire naturelle. La vitesse de bio-résorption est toutefois fonction :
* de la composition de la céramique (la présence d'ions magnésium par exemple diminue la vitesse de résorption).
* de la porosité : la taille, la forme et la distribution des pores, influencent la vitesse de résorption en faisant varier la surface de contact.
* de la taille des grains de la céramique (10, 25 , 29).

== Choix du site d’implantation ==

Le développement des structures embryonnaires ou fœtales, la différenciation fonctionnelle d'organes ou de fragments d'organes adultes, la biocompatibilité des matériaux peuvent être étudiés de façon simple chez l'animal.
L'expérimentateur doit disposer d'un site de greffe ou d'implantation bien délimité, facile à identifier même au terme d'une expérience de longue durée, plusieurs semaines, éventuellement plusieurs mois.

De nombreux sites ont été proposés pour étudier le comportement in vivo des matériaux utilisés en Odontologie ; notre travail propose la région sous-capsulaire rénale du rat albinos de souche Wistar, espace virtuel accessible à la microchirurgie sous anesthésie générale (31).

Il nous a paru utile, de connaître d'abord l'animal (il faut se plier à ses exigences pour s'en servir utilement et établir ses caractéristiques pour en faire un sujet d'expérience) et de préciser la structure du site d'implantation.

=== Choix de l’animal : Le rat albinos de souche Wistar ===

Les animaux de laboratoire prennent une importance sans cesse croissante dans la recherche scientifique ; le rat en particulier est très utilisé dans divers domaines. L'élevage des rats dans le laboratoire constitue un exemple frappant ; il est contrôlé, rationalisé, sous alimentation synthétique, dans un milieu artificiel, à température, aération et humidité réglables.

Le rat albinos est l'un des plus petits animaux de laboratoire, il est économique, requiert peu d'espace et peu de nourriture ; on peut aussi en utiliser un grand nombre pour une expérience donnée, sa vie est courte et sa puberté précoce (15, 31).

Malgré des conditions d'existence artificielles le rat albinos continue à vivre et à se reproduire en captivité depuis de nombreuses générations et il joue un rôle d'auxiliaire précieux de la recherche scientifique. Comme chaque espèce animale, le rat présente un intérêt pour l'étude des sciences comparées : anatomie, physiologie, pathologie... Il héberge des parasites et des microbes transmissibles à l'homme et aux animaux et a permis de mieux connaître certains d'entre eux(15, 31).

Le rat albinos de souche Wistar est très utilisé pour l'étude de la biocompatibilité des matériaux. La cancérologie doit beaucoup aux rats ; ces animaux sont sensibles aux tumeurs spontanées ou provoquées (15, 31).
 
==== Habitation ====

L'habitat des rats nécessite le maintien de la température entre 24°C et 26°C pour permettre la reproduction toute l'année, les écarts brusques de température sont dangereux et risquent de provoquer des pneumonies (15, 31).

Les rats sont soumis à une aération, à l'humidité dont le degré le plus favorable est situé entre 40% et 70% et à un éclairage  de 12 heures par jour. La lumière est distribuée par des ampoules électriques ordinaires ou par des lampes émettant des rayons ultraviolets.

Les rats sont entretenus dans des cages disposées, le plus souvent, sur des rayons formés de cornières métalliques, fixées aux murs ou suspendues au plafond. Il semble intéressant de les agencer en blocs mobiles, sur roulettes, de 12 à 15 cages par exemple, ce qui facilite le nettoyage. Pour l'examen des animaux, une table ou une paillasse est réservée à cette indispensable opération périodique.

L'intérieur d'une cage doit être aménagé de façon à permettre l'alimentation et la reproduction des animaux. Une litière est indispensable tant aux jeunes qu'aux adultes (15, 31). Le besoin d'activité est  en relation avec les phénomènes vitaux. Un rat doit pouvoir aller, venir et surtout ronger.

==== Nutrition ====

Le régime alimentaire pour les rats de laboratoire doit remplir deux conditions :
* répondre aux besoins nutritifs,
* être identique à lui-même dans le temps et dans l'espace.

Les rats se nourrissent d'aliments composés essentiellement de céréales, de farines de viandes, d'os de poisson, de poudre de lait entier ou écrémé, etc. À ces produits de base sont associés en faible quantité des sels minéraux, de l'huile de foie de morue, de la levure de bière... L'eau de boisson doit être fournie à satiété (15, 31).

==== Reproduction ====

La consanguinité qui permet la création de lignées « pures » est une méthode très utile par son action sur le génotype et sur le phénotype des animaux. Les animaux de laboratoire doivent toujours être choisis dans des lignées issues d'un même couple (31). Le rat albinos est apte à la fécondation et à la reproduction dès l'âge de trois mois mais il est préférable d'attendre quatre mois. On choisit un jeune rat robuste qu'on laisse dans une cage pendant quelques jours avec 3, 4 ou 5 femelles. Dès qu'une femelle est pleine, on l'isole dans une cage à deux compartiments où elle prépare son nid avec des débris de coton ou de copeaux (15, 31).
Dans le laboratoire où nous travaillons, il est de coutume de mettre ensemble deux femelles et un mâle. L'isolement a lieu dans des cages simples.

La durée de gestation est de vingt et un jours, la rate met bas 4 à 5 petits dépourvus de poils et aveugles pendant onze à treize jours. L'allaitement est assuré pendant deux semaines. Moins d'un mois après la naissance, les jeunes rats s'alimentent normalement et peuvent être séparés de leur mère. Dès l'âge de trois à quatre mois ils peuvent servir à l'expérimentation. Une femelle reproduit tous les trois mois, quatre portées sont donc possibles chaque année (15, 31).

=== Caractères généraux du rein du rat ===

Bien qu’il soit organisé différemment de celui de l’homme, chez le rat, comme chez tous les mammifères, le rein est délimité par une capsule conjonctive. Cette formation contient des vaisseaux sanguins et des fibres nerveuses végétatives. À l'intérieur de cette capsule, le parenchyme rénal se répartit en deux zones principales, la zone corticale et la zone médullaire dans laquelle on individualise une portion externe et une portion externe (18).

Dans les deux zones principales des structures épithéliales d'origine mésodermique sont disposées dans un interstitium conjonctif qui est plus abondant dans la zone médullaire. Cet interstitium sert de voie de passage aux vaisseaux sanguins et lymphatiques. L'artère rénale donne naissance à un dispositif en arcade localisé au niveau de la face profonde de la zone corticale : des branches artériolaires se détachent de cette arcade vasculaire pour assurer l'irrigation de la zone corticale d'une part et de la zone médullaire d'autre part. Les dispositifs veineux et lymphatiques présentent la même répartition.

La zone corticale contient les néphrons, unités morphologiques et fonctionnelles, qui élaborent l’urine et contiennent un dispositif endocrine ; la zone médullaire contient principalement les canaux excréteurs qui s'ouvrent dans le  bassinet rénal (31).

=== Structure d’un néphron ===

Chaque néphron comprend deux zones, le corpuscule de Malpighi et le tube urinaire dans lequel on individualise trois segments, le tube contourné proximal,  l’anse de Henlé, le tube contourné distal.

==== Structure du corpuscule de Malpighi ====

À peu près circulaire sur les coupes, il possède un pôle vasculaire et un pôle urinaire qui s'ouvrent dans le tube urinaire ; il est délimité pas une structure amorphe, la capsule de Bowmann, formation épithéliale pavimenteuse dont la face externe est doublée par une lame basale et un réseau de fibres de réticuline étroitement associé à la charpente fibrillaire de l’interstitium rénal. La face externe de la capsule de Bowmann délimite la chambre glomérulaire, cavité d'autant plus irrégulière qu'elle est occupée par le glomérule rénal, dispositif complexe formé de capillaires étroitement associés à deux groupes de cellules, le mésangium d'une part dans sa portion centrale, les padocytes d'autre part, qui séparent les capillaires de la chambre glomérulaire (31).

Au niveau du pôle vasculaire du corpuscule ou observe une artériole afférente et une artériole efférente. L’artériole afférente se ramifie en branches qui donnent chacune naissance à des capillaire dont le trajet est très sinueux : ils confluent pour donner naissance aux petits vaisseaux origine de l’artériole efférente. L'ensemble des capillaires de ce flocule est occupée par le mésangium où des cellules polymorphes, sécrétoires et phagocytaires sont disposées dans une matrice homogène.

L'endothélium des capillaires est fenêtré, parfois traversé par des expansions cytoplasmiques des cellules mésangiales. En dehors de la zone mésangiale, cet endothélium est doublé par une lame basale constituée de trois feuillets. C'est par l'intermédiaire de cette zone que les capillaires sont associés à un revêtement épithélial continu et plicaturé, paroi interne de la chambre glomérulaire. Ce revêtement est formé par les padocytes cellules qui possèdent des expansions cytoplasmiques ramifiées dont les extrémités sont associées à la lame basale des capillaires. Au niveau du pôle urinaire les cellules de la capsule de Bowmann sont associées aux premières cellules de la paroi du tube urinaire (31). 
 
==== Structure du tube urinaire ====

Chacun des segments de ce tube a une paroi épithéliale, doublée par une lame basale et un réseau de fibres de réticuline. Le tube contourné proximal possède une lumière délimitée par des cellules légèrement prismatiques : ce sont les néphrocytes dont le pôle apical porte une bordure en brosse très importante dont le glycocalix est riche en enzymes et dont le pôle basal a un aspect strié, aspect lié aux expansions cytoplasmiques occupées chacune par une mitochondrie.

L’anse de Henlé fait suite au tube contourné proximal : elle présente une branche descendante dont la lumière est délimitée par des cellules aplaties dont le pôle apical est hérissé de nombreuses micro-villosités  et une branche ascendante à paroi formée de cellules cubiques ou légèrement prismatiques : leur pôle basal est d’aspect strié.

Le tube contourné distal est localisé dans la portion la plus externe de la zone corticale. Dans sa portion disposée au voisinage du pôle vasculaire du corpuscule de Malpighi, l’épithélium qui délimite sa lumière est épaissi : c’est la macula densa étroitement associée à une zone épithélioide de la paroi de l’artère afférente, formant ainsi l’appareil juxta-glomérulaire. La paroi du tube contourné distal est constituée de cellules cubiques dont le pôle basal a un aspect strié (18).

==== Structure des tubes excréteurs ====

Ils prennent naissance dans la portion externe de la zone corticale et résultent de la confluence de plusieurs tubes contournés distaux. Ils traversent toute l’épaisseur de la zone corticale et confluent au niveau de la zone médullaire pour donner naissance à des canaux collecteurs de diamètre croissant. Leur paroi est constituée de cellules épithéliales qui deviennent légèrement prismatiques au fur et à mesure qu’augmente le diamètre tubulaire (31).

=== Notions histophysiologiques ===

L’élaboration de l’urine résulte d’un double processus. La filtration glomérulaire donne naissance à l’urine primitive dont la composition est proche de celle du plasma sanguin, sauf en ce qui concerne les protéines. Cette filtration est régulée par les cellules du mésangium.

Les cellules du tube urinaire sont caractérisées par des propriétés de réabsorption et de perméabilité qui permettent la formation de l’urine définitive. Les néphrocytes du tube contourné réabsorbent l’eau, le sodium, le glucose, les acides aminés, des phosphates et des lactases contenus dans l’urine primitive. La branche descendante de l’anse de Henlé est perméable à l’eau et aux électrolytes alors que la branche ascendante, imperméable à l’eau, assure la réabsorption du sodium qui est rejeté dans l’interstitium. La concentration de l’urine se termine au niveau du premier segment des tubes excréteurs. 

L’aldostérone contrôle la fonction de la branche ascendante de l’anse de Henlé : l’hormone antidiurétique contrôle la réabsorption de l’eau au niveau des tubes excréteurs.

L’appareil juxta-glomérulaire élabore la rénine qui provoque la transformation de l’angiotensinogène d’origine hépatique en angiotensine dont la forme définitive angiotensine II a une action vasoconstrictrice.

Le parenchyme rénal élabore au niveau de l’interstitium différentes substances parmi lesquelles l’érythropoïétine  qui règle la production de globules rouges. La richesse en vaisseaux de cet interstitium et les cellules conjonctives qu’il contient font que le parenchyme du rein peut être le siège de réactions immunitaires (31).

=== Structure du site d’implantation ===

Chez l'embryon, le blastème méta-nephrogène, portion non segmentée du mésoderme intermédiaire postérieur, donne naissance à deux groupes de structures visibles au terme de l'organisation du rein :
* Le parenchyme rénal, principalement constitué de structures épithéliales, les corpuscules de Malpighi, les tubes urinifères, répartis dans un stroma conjonctif et vasculaire dont l'importance s'accroît à partir du cortex de l'organe en direction de sa zone médullaire et de son hile.
, La capsule rénale, structure conjonctive étroitement appliquée à la surface de l'ensemble de l'organe.

Dans le cas le plus schématique chez le rat, la capsule est constituée de deux plans collagènes, fibres à disposition plexiforme et lames collagènes, le plan le plus interne est séparé du cortex rénal par une couche discontinue de fibroblastes. La même organisation est visible entre les deux plans fibreux dont le plus externe est directement associé au tissu adipeux péri-rénal (18, 31, 45).

Dans certaines zones de la capsule, les cellules conjonctives sont plus nombreuses entre les deux plans fibreux, elles sont alors disposées autour des artérioles et des capillaires (figures 1 in 31).


[[File:Grossissement 40. Vue générale du parenchyme rénal et de la capsule rénale qui le délimite.jpg|thumb|400px|center|Figure 1 : grossissement 40, vue générale du parenchyme rénal (PR) et de la capsule rénale (CR) qui le délimite (31).]]


[[File:Grossissement 40, la capsule rénale apparaît sous forme d’une mince couche claire en haut.jpg|thumb|400px|center|Figure 2 : grossissement 40, la capsule rénale (CR) apparaît sous forme d’une mince couche claire en haut ; au-dessous les tubes rénaux et les corpuscules de Malpighi.]]

== Technique expérimentale ==

=== Préparation des implants ===

==== Le matériau ====

Notre choix s'est orienté vers une poudre de phosphate tricalcique. Nous avons utilisé pour cette étude un produit commercial de grande pureté : Rectapur (pureté supérieure à 99%) des laboratoires PROLABO, les impuretés étant le plomb (0,002%), le fer (0,005%), le chlore (0,02%), l'oxyde sulfurique (0,1%). Avant d'être utilisée la poudre est desséchée à 300 °C.

==== Mise en forme des échantillons ====
   
La poudre est finement broyée puis additionnée de quelques gouttes d'alcool polyvinylique afin d'assurer la cohésion entre les particules, elle est ensuite
compactée  à l'intérieur d'un cylindre d'alumine de 3 mm de diamètre et sur une longueur de 3 à 4 millimètres.

Les cylindres de phosphate tricalcique obtenus sont  portés à 600 °C (la montée en température est lente et régulière, elle se fait à la vitesse de 1 °C par minute), les échantillons sont maintenus à cette température durant deux heures, afin d'éliminer le liant organique sans détruire la cohésion de la pièce. Les échantillons sont ensuite portés à 800 °C (la vitesse de montée en température est de 5°C par minute), ils sont maintenus à cette température pendant deux heures pour leur permettre d'acquérir une certaine dureté.

Les bâtonnets cylindriques obtenus ont été usés par des billes d'alumine pour leur donner une forme à peu près sphérique d'environ 2 à 3 millimètres  de diamètre. Ainsi mises en forme ces billes subissent alors un dernier traitement thermique à 1 350 °C (la vitesse de montée en température est de 5 °C par minute) qui leur confère leur microstructure finale. La recherche de fissures ou de craquelures résultant du frittage est effectuée et les échantillons endommagés sont éliminés (37).

==== Analyse par diffraction x ====

Pour interpréter les résultats il existe des fiches qui comportent les caractéristiques nécessaires. Les chiffres relevés sur le diffractogramme  sont conformes à ceux de la fiche A.S.T.M. (''American Society For Testing Materials'') n° 969 a. Le spectre obtenu correspond bien à celui du  phosphate tricalcique (37).

==== Analyse au microscope électronique à balayage ====

L'examen au microscopique électronique à balayage du matériau étudié a été réalisé à l'aide d'un microscope JEOL équipé d'un système d'analyse en énergie, sous une tension  de 25 kV. L'analyse de la bille de phosphate tricalcique au MEB indique la présence d'une granulométrie évaluée inférieure à 10 micromètres avec prédominance de grains fins. Il en résulte une taille des pores inférieure à 50 micromètres (37).

==== Analyse par microsonde ====

La microanalyse met en évidence le caractère biphasique du matériau et révèle la présence des deux éléments principaux, le calcium et le phosphore (40).

=== L’implantation sous capsulaire rénale ===

==== Les lots de rats ====

Notre choix s’est porté sur le rat albinos de souche Wistar entretenue au Laboratoire d'Histologie et d'Embryologie de l'UFR 3 des Sciences Médicales en lignée consanguine depuis 1966, à partir d'un seul couple. Ces animaux vivent dans des cages collectives. La température du local est maintenue  à 24-26 °C, l’éclairage est régulier (12 heures par jour).

L'alimentation est équilibrée, de qualité constante, composée de blé, d'arachide, de soja cuit, de poisson, de sang, de levure, de lait, de sucre, de graisse : ce complexe est supplémenté en sels minéraux (formule U.A.R.) et enrichi en vitamines. Elle est dure et présentée sous forme de cylindres, elle est mise dans un espace prévu pour cet effet. La dose quotidienne est à peu près 30 grammes. L'eau est fournie à volonté dans des flacons ressemblant aux biberons.

Dans le stock animal mis à notre disposition nous avons utilisé 32 rats adultes et mâles, pour éviter toute perturbation liée au cycle endocrinien. Leur poids varie entre 360 grammes et 450 grammes, ils sont  répartis en 4 groupes de 8 rats. Chaque lot comporte quatre individus prélevés dans l'animalerie préopératoire et transférés en salle d'opération.

==== Instrumentation ====

Elle est classique. Le plateau  comprend :
- des ciseaux ;
- des presselles ;
- une pince à disséquer mousse ;
- une pince à petites griffes ;
- une aiguille et fils de suture ;
- une poire à air pour réanimation
… etc.

==== Anesthésie ====

L'anesthésie générale de l'animal est réalisée à l'aide de bacs contenant du diéthyloxyde (éther), elle est complétée au moment de l'intervention par de l'isofluorane appliqué à la demande avec un masque de Foren. Deux à trois minutes suffisent pour obtenir une bonne anesthésie. Cette technique se révèle être la meilleure, le taux de mortalité est réduit comparativement à l'anesthésie par injection intra-péritonéale.

==== Pesée des rats ====

Chaque rat a été pesé afin de suivre l'évolution de son poids au terme de l'expérimentation.

==== Identification des animaux ====

Après anesthésie, afin de différencier les animaux, nous avons établi un code selon le nombre dans la série : OI (oreilles intactes), ODF (oreille droite fendue), OGF (oreille gauche fendue), OF (oreilles fendues), ODC (oreille droite coupée), OGC (oreille gauche coupée), OC (oreilles coupées).

==== Technique chirurgicale ====

Après avoir relevé le poids des animaux, nous procédons au rasage et à la désinfection du flanc gauche à l'alcool. Toute l'intervention est ensuite conduite stérilement. Le choix s'est porté sur le rein gauche du fait de l'accès plus facile car son pédicule est plus long, en outre le rein droit est proche du foie.

Après incision des plans cutané et musculaire du flanc gauche, le rein est extériorisé par traction sur le tissu adipeux péri-rénal particulièrement abondant au voisinage du pôle inférieur de l'organe.

Sous examen microscopique, la capsule rénale est incisée sur 5 mm de long, dans une zone non vascularisée, au voisinage du pôle supérieur et sur la face ventrale du rein. À l'aide d'une spatule mousse, elle est décollée du parenchyme rénal sur une longueur de 8 à 10 mm et une largeur de 7 à 8 mm.
 
La structure conjonctive doit être décollée du parenchyme rénal à la surface duquel elle est apposée. L'incision, le décollement de la capsule rénale et la mise en place de l'implant ne doivent pas provoquer d'hémorragie d'origine capsulaire ou parenchymateuse pour que la cicatrisation ultérieure évolue de façon simple.

La bille de phosphate tricalcique, déposée au niveau de l'incision capsulaire, est poussée à l'aide de la spatule dans l'espace créé entre la capsule et le parenchyme, le rein est ensuite remis en bonne position dans sa loge.
Puis on procède à des sutures en deux plans : pour le plan musculaire nous avons utilisé des fibres résorbables, alors que pour le plan cutané notre choix s'est porté sur du fil en soie.

L'opération a lieu dans des conditions d'asepsie et d'antisepsie optimales. Après intervention, les animaux sont placés dans des cages par groupe de 4 rats et laissés libres de leurs mouvements, ils sont entretenus sans régime alimentaire spécial.

=== Récupération des reins ===

==== Pesée des rats ====

Nous avons pesé régulièrement les rats afin d'étudier le retentissement de l'implantation du matériau sur l'évolution du poids des animaux.

==== Prélèvement des reins ====

Les animaux ont été sacrifiés par groupe de 8 rats à 1 mois, 2 mois, 3 mois et à 6 mois. Les règles d'asepsie sont similaires à celles appliquées pour l'implantation des billes en phosphate tricalcique.

Les rats sont placés dans une enceinte contenant une forte concentration d'éther qui entraîne une syncope terminale en 1 à 2 minutes.
Une incision oblique latéro-dorsale, placée entre l'épine iliaque et le gril costal,  parallèle à la première incision, permet de découvrir le plan musculaire puis la loge rénale. Nous examinons attentivement le rein et les différents organes au voisinage immédiat et à distance. Le rein est extériorisé de la cavité abdominale, ensuite nous sectionnons son pédicule, l'organe récupéré, porteur de l'implant, est déposé dans du liquide de Bouin.

Pour la conservation des organes plusieurs liquides sont proposés, mais au cours d'une expérimentation la règle est de se plier aux conditions de travail du laboratoire d'accueil, le liquide utilisé est de manipulation courante.

=== Préparation des prélèvements ===

Chaque prélèvement après sacrifice bénéficie d'un examen macroscopique minutieux. Cet examen intéresse également les billes en phosphate tricalcique.

==== Préparation des reins ====

Pour l'examen au microscope optique, tous les reins sont traités de façon identique.

==== Fixation ====

L'histologie permet d'étudier la morphologie des tissus vivants. Donc le premier problème à résoudre après le prélèvement des tissus est leur fixation. Cette manipulation comprend la mort du tissu et l’immobilisation de ses structures et ses composantes dans un état semblable à l'état vivant.

Nous avons utilisé le liquide de Bouin qui est considéré comme un excellent fixateur, il est d'utilisation courante en histologie. Le liquide de Bouin est composé d'une solution aqueuse saturée d'acide picrique, de formol et d'acide acétique.

Après fixation dans le liquide de Bouin, une coupe sagittale du rein le divise en 2 parties, une des 2 parties comporte l'implant en phosphate tricalcique.

==== Déshydratation ====

Les prélèvements sont déshydratés à l'aide d'alcools, éclaircis par le toluène et imprégnés dans la paraffine.

==== Enrobage ====

Le tissu rénal imprégné de paraffine est inclus dans un bloc de paraffine, le bloc est ensuite sectionné, en coupe d’une épaisseur, au moyen d’un microtome.

==== Coupes au microtome ====

Nous avons utilisé le microtome rotatif de Minot. Le rasoir est fixe et la pièce se déplace verticalement pendant la réalisation des coupes. Sous l'action de la chaleur produite par le frottement avec le rasoir, la paraffine fond légèrement, ce qui permet d'avoir une adhérence des coupes les unes aux autres pour former un ruban, nous obtenons ainsi un grand nombre de coupes à partir d'un même bloc.

==== Étalement des coupes ====
 
Les tissus inclus dans la paraffine sont fortement comprimés pendant la coupe ; afin d'atténuer cette compression on procède à l'étalement des coupes. On utilise une plaque chauffante dont la température est à 30 °C, sur laquelle on dépose les lames que l'on recouvre de liquide d'étalement à base d'eau distillée et d'albumine. On y place les coupes, puis on les étale, les plis qui demeurent sont enlevés à l'aide d'aiguilles à dissection. À la fin de l'opération on absorbe l'excès de liquide avec un papier buvard et enfin on laisse les lames sécher sur la platine.

==== Coloration ====

On procède d'abord au déparaffinage et à l'hydratation des coupes ; pour que les colorants puissent pénétrer dans le tissu, il faut en retirer la paraffine et l’imprégner d'eau. On commence par passer les coupes dans des bains de toluène pour éliminer la paraffine. La deuxième étape consiste à commencer par des bains de 5 minutes à 10 minutes dans l'éthanol à différents degrés suivis d'un traitement de 5 à 10 minutes dans l'eau.

La coloration permet de mettre en évidence les noyaux, le cytoplasme et les fibres de collagène ; elle permet ainsi de se faire une idée de la topographie générale du tissu. Le temps nécessaire à la coloration varie énormément d'une méthode à l'autre. Dans cette étude nous avons utilisé deux techniques de coloration : le trichrome de Goldner et le trichrome de Masson.

Ces deux méthodes dérivent de la technique du trichrome de Mallory, elles reposent sur les différences de perméabilité qui existent entre les fibres de collagène et les autres éléments acidophiles du tissu. Elles comprennent l'utilisation, en séquence, de fuchsine acide, d'acide phosphomolybdique et du bleu d'aniline (ou vert lumière) et elles permettent la coloration : des noyaux, chromatine et nucléoles en bleu foncé à noir, du cytoplasme en rouge, des globules rouges et granulations éosinophiles en rouge,  du collagène en bleu (bleu d'aniline) ou en vert (vert lumière).

==== Montage ====

Les coupes sont  montées de façon classique. Les lames sont groupées par lots qui correspondent aux jours des prélèvements et sont observées au microscope optique muni d'un appareil photographique (Reichert-Zetopan-Microstar IV).

=== Préparation des billes pour l’analyse ===

Pour l'analyse des billes de phosphate tricalcique, nous procédons à la métallisation de la surface par un dépôt de carbone pour l'étude au microscope électronique à balayage. Pour l'analyse par microsonde les billes sont incluses dans la résine.


= Résultats =

== Suites opératoires ==

Tous les animaux ont survécu plusieurs semaines voire des mois jusqu'aux dates prévues pour leurs sacrifices, ils ont gardé tous leurs caractère, la cicatrisation est parfaite, après 20 jours seule la taille des poils atteste que l'animal a été opéré.

==  Évolution du poids des animaux ==

La croissance pondérale moyenne d'un jeune rat albinos est de 44% en 12 jours, soit une prise de 53 grammes pour un rat d'un poids initial de 120 grammes ; cette augmentation de poids rapide chez le jeune devient lente chez l'adulte. Au cours de nos expérimentations, nous avons constaté que d'une manière générale il y a une augmentation du poids des animaux sauf pour un animal qui a gardé son poids initial et pour deux sujets qui ont perdu du poids, ces deux derniers ont fait des syncopes au cours de l'intervention.

Le contrôle et la surveillance régulière des animaux a permis de relever l’augmentation de leurs  poids :
-  les deux premiers mois, de 5 à 30 grammes ;
- le troisième mois, de 13 à 40 grammes. Un seul animal a gardé le poids initial, les deux rats qui ont fait des syncopes ont perdu 12 à 22 grammes ;
- dans le sixième mois, de 30 à 75 grammes.

L'évolution du poids des animaux relevée au cours de notre expérimentation correspond aux statistiques du laboratoire. Nous pouvons donc constater que l'implantation sous la capsule rénale du rat n'a pas perturbé la croissance des animaux.

== Observations  macroscopiques ==

Les observations macroscopiques au moment des prélèvements des organes ont permis de mettre en évidence :
- L'implant qui apparaît de forme circulaire, de couleur blanche, disposé à la surface du parenchyme rénal, sous la capsule rénale.
- Les organes au voisinage du rein qui présentent une structure normale. Nous avons pu constater l'intégrité de la cavité abdominale dans tous les cas. Parfois il y a adhésion entre le rein et l'un des organes voisins, sans perturbation des résultats. 

Sur les billes de phosphate tricalcique extraites, on note  des fragments de tissus accrochés tout autour.


[[File:Aspect normal du rein du rat et des organes voisins.jpg|thumb|400px|center|Figure 3 : aspect normal du rein et des organes voisins]]

== Résultats histologiques ==

L'observation des préparations au microscope est une véritable lecture « à livre ouvert » faite à faible grossissement pour se rendre compte de la disposition relative des diverses structures. Le fort grossissement, employé secondairement, permet l'étude de points particuliers intéressant les « zones frontières » entre la capsule et le parenchyme rénal, la capsule et l'implant, et l'implant et le parenchyme rénal.

L'ensemble des coupes a permis un examen microscopique des différentes réactions cellulaires ou fibreuses présentes au voisinage immédiat et à distance du site d'implantation. Les lames ont été observées dans l'ordre chronologique et groupées par lots correspondant aux jours du prélèvement.

=== Après 28 jours ===

Le tissu rénal a un aspect histologique normal, aucune altération n'a été observée au niveau du tissu épithélial avoisinant la zone d'implantation ou à distance.

Le site est circonscrit par un tissu granulomateux bien organisé, riche en fibroblastes, en vaisseaux néoformés, avec prolifération cellulaire autour du site d'implantation.

[[File:Grossissement 400, présence d'une réaction conjonctive importante et d'une invasion cellulaire.jpg|thumb|400px|center|Figure 4 : grossissement 400, nous remarquons la présence d'une réaction conjonctive importante (CJ) et d' une invasion cellulaire (IC) ; les structures épithéliales du parenchyme rénal sont intactes.]]

=== Après 64 jours ===

On note la présence de fragments de l'implant au voisinage immédiat du site d'implantation. Le tissu granulomateux est mieux organisé. On note le nombre restreint de cellules inflammatoires chroniques mononucléées.

Les différentes observations ne révèlent en aucun cas un enkystement, au contraire on observe des plages de tissus qui témoignent d'une excellente cicatrisation. L'observation des tissus situés à distance de l'implant n'a rien révélé d'anormal.

[[File:Grossissement 400, on note un épaississement du tissu conjonctif, une invasion cellulaire et fibrillaire et la présence de fragments de l'implant.jpg|thumb|400px|center|Figure 5 : grossissement 400, on note un épaississement du tissu conjonctif, une invasion cellulaire et fibrillaire et la présence de fragments de l'implant.]]

=== Après 84 jours ===

La question qui nous préoccupe le plus est de savoir si au bout de la douzième semaine, le tissu granulomateux et les cellules inflammatoires disséminées vont disparaître pour laisser place à un tissu parfaitement cicatrisé comme le rapportent les travaux de nombreux auteurs (7).

Il est intéressant de constater qu’après trois mois d'implantation le diamètre du site l a diminué, cette diminution ne peut être liée qu'au caractère biorésorbable du phosphate tricalcique.

Au voisinage immédiat de l'implant la réaction conjonctive est beaucoup plus importante que pour les 2 premiers mois. À distance de l’implant les différentes structures rénales sont intactes, toutes ces observations témoignent que l'implant est parfaitement toléré.

[[File:Grossissement 400, on note une réaction cellulaire avec présence de fibres collagènes orientées dans tous les sens qui ont tendance à s'épaissir.jpg|thumb|400px|center|Figure 6 : grossissement 400, on note une réaction cellulaire avec présence de fibres collagènes orientées dans tous les sens  qui ont tendance à s'épaissir ; il n’y a pas de signes de cytotoxicité à tous les niveaux du tissu rénal, le tissu conjonctif fibreux est dépourvu de cellules inflammatoires, le parenchyme rénal est intact.]]

=== Après 168 jours ===

On met en évidence une réaction fibreuse importante tout autour du lieu d’implantation. La présence de cette formation fibreuse est vraisemblablement liée aux propriétés d'induction du phosphate tricalcique. La cicatrisation des tissus est parfaite et le site est bien stabilisé.

L'aspect déchiqueté de la périphérie du site d'implantation (dû à l'élimination de la bille avant la coupe) prouve l'adhésion du matériau aux tissus.

Les plages de tissu cicatriciel diffèrent totalement de l'aspect des tissus observés les premiers mois. Le parenchyme rénal avoisinant ou à distance du site d'implantation ne présente aucun signe anormale d'inflammation, on note l'état normal des tubules rénaux et des corpuscules de Malpighi.


[[File:Grossissement 400, détail de la figure précédente, on note la présence d'une structure fibreuse épaisse.jpg|thumb|400px|center|Figure 7 : grossissement 400, on note la présence d'une structure fibreuse épaisse (SFE).]]


[[File:Grossissement 400, après six mois, comme pour les mois précédents, à distance du site d'implantation les structures épithéliales du parenchyme rénal et les corpuscules de Malpighi sont restés intacts.jpg|thumb|400px|center|Figure 8 : grossissement 400, après six mois, comme pour les mois précédents, à distance du site d'implantation les structures épithéliales du parenchyme rénal et les corpuscules de Malpighi sont restés intacts.]]

== Interprétation des résultats histologiques ==

Les 32 rats opérés sont restés vivants alors que le pourcentage de perte des animaux dans le laboratoire est de 2 à 5 %.

Il nous faut reconnaître que les conditions idéales d'intervention sont rarement réunies dans une expérimentation animale. Nous avons échappé aux servitudes qui en découlent et restons très satisfaits des résultats positifs obtenus.

La cicatrisation de l'incision est rapide pour tous les animaux opérés,  seule la  taille des poils au niveau du flanc gauche  atteste que les rats ont été opérés.

L'évolution du poids des animaux correspond aux statistiques du laboratoire, la légère diminution observée pour deux rats peut être attribuée au fait que ces deux animaux ont fait des syncopes au cours des interventions, l'augmentation lente pour les autres animaux est normale car nous avons utilisé des rats adultes.

L'aspect normal des organes vitaux au voisinage du rein et les observations déjà citées prouvent que la technique expérimentale utilisée est menée dans des conditions optimales.

La présence de particules de phosphate tricalcique au niveau du site d'implantation témoigne du caractère bio-réactif de ce matériau sous la capsule rénale. La diminution du diamètre des billes en phosphate tricalcique confirme les résultats observés par d’autres auteurs (en milieu biologique ce matériau subit une dissolution). Nous regrettons de ne pas avoir utilisé une poudre à granulométrie grossière et un mode d'usinage qui met en œuvre un produit de liaison calcinable à basse température.

Dans les premières semaines qui suivent l'intervention, la présence de cellules inflammatoires disséminées s'inscrit dans les suites opératoires normales, à l'évidence leur nombre diminue dans le temps pour devenir nul à 12 semaines (7). Il est donc réconfortant de constater que même avec des réactions inflammatoires résiduelles au bout des premières semaines, il se produit des formations collagéniques intéressantes qui apportent la preuve du caractère régressif de l'inflammation à ce stade.

L'aspect déchiqueté des sites d'implantation associé à l'irrégularité des frontières qui rappelle un aspect en carte de géographie est une des preuves qu'il y a eu réaction entre le biomatériau testé et le site receveur.

La mise en évidence de cellules conjonctives et de plages de tissus stabilisés est vraisemblablement liée aux propriétés d'induction cellulaire que possède le phosphate tricalcique.

L'aspect déchiré de la périphérie des sites d'implantation témoigne de l'adhésion à l'interface matériau-tissus et du début de colonisation des vacuités, vacuités résultant de la dissolution de particules du phosphate tricalcique par les cellules conjonctives néoformées. 

Dans tous les cas l'aspect du tissu rénal est resté normal, aucune altération n'a été mise en évidence au niveau des tissus épithéliaux et conjonctifs au voisinage immédiat ou à distance du site d'implantation.

== Analyse des implants après expérimentation ==
 
Les échantillons de phosphate tricalcique ont été extirpés après 1, 2, 3 et 6 mois d'implantation, observés et analysés au microscope électronique à balayage (JEOL). La métallisation de la surface des échantillons a été assurée par un dépôt de carbone. La caractérisation au microscope électronique à balayage a été effectuée sur des échantillons fracturés et d'autres non fracturés. 

La microstructure interne du matériau fracturé rappelle singulièrement celle du départ (existence de pores entre les grains) et semble indiquer que le cœur de l'échantillon n'a pas été modifié même après 6 mois d'implantation. Aucun changement n'a été révélé dans la structure interne de la bille (40). 

Les micrographies de la surface des échantillons non fracturés sont extrêmement complexes, toutes les billes sont recouvertes par du tissu rénal ce qui rend difficile l'analyse de la structure de surface de la bille sauf par endroits où nous n'avons pas rencontré de différence significative de la structure externe après implantation par rapport à celle du départ.

L'évaluation de la concentration en éléments calcium et phosphore dans un échantillon après six mois d'implantation a été effectuée par la microsonde EDAX couplée au microscopique électronique à balayage. La  microanalyse permet d’évaluer qualitativement et même quantitativement les éléments constitutifs du matériau, elle complète toujours l'observation au microscope électronique à balayage et permet d'obtenir des micrographies qui mettent en évidence les raies cqrqct2ristiaues des différents éléments présents dans le matériau analysé. Parfois une raie est masquée par une autre, la lecture de la micrographie devient alors difficile.

L’analyse des éléments calcium et phosphore a été effectuée sur des échantillons enrobés dans la résine. Cinq zones différentes de dimensions 40 micromètres x 30 micromètres ont été analysées au cœur de l'échantillon et à sa surface.

Une variation très nette de l'intensité de la raie K de l'élément calcium est observée lorsqu'on passe de la surface de l'échantillon au cœur de celui-ci. Le rapport des intensités des raies K passe de 6,30 (cœur de l'échantillon) à 4,5 (surface) avec une bonne reproductibilité. Bien qu'elles ne correspondent pas au rapport atomique Ca/P, ces valeurs sont toutefois significatives d'une résorption des ions Ca2+ par les tissus environnants (37).


= Discussion =

Le nombre de rats utilisés dans des conditions opératoires identiques, joint au nombre de coupes histologiques réalisées, confirment in vivo, la constance des résultats d'évaluation &quot;en lecture directe&quot;.

L'absence de mortalité et l'évolution normale du poids des animaux sont des critères suffisants pour justifier l’intérêt du site choisi.

Il est encourageant de constater que l'implantation du phosphate tricalcique sous la capsule rénale ne perturbe pas la croissance des animaux.

Le  site choisi  répond aux conditions idéales d'implantation. Quatre à cinq jours après leur implantation, les éléments cellulaires ou tissulaires et les fragments d'organes sont vascularisés à partir de la capsule (31).

Les conclusions de cette expérimentation sont tirées d'observations histologiques qualitatives. La moindre toxicité au niveau de la zone épithéliale et au niveau du tissu conjonctif se serait traduite par des micro-abcès, l'expulsion des implants et des nécroses qui auraient provoqué la mort des animaux (31). Ces états n'ont jamais été observés durant les expérimentations. Au contraire, les structures rénales sont souvent en contact avec l'implant mais rigoureusement intactes.

Contrairement à des implants en alumine  et en zircone, implantés sous la capsule rénale de rats pour une période de un mois qui ont laissé place à des sites parfaitement réguliers (1), les billes en phosphate tricalcique que nous avons testées ont entraîné un déchirement des sites d'implantation qui leur donne une allure crénelée. Il est intéressant de constater qu'à proximité des sites les réactions tissulaires sont différentes.

Les réactions tissulaires observées au niveau des sites d’implantation, témoigne la bonne tolérance des implants à morphologie adaptée. Les implants  laissées en place pendant un mois sous la capsule rénale de rats n'ont entraîné aucune réaction négative identifiable, alors que pour la même période, des échantillons en zircone et en Dacron qui présentent des bords irréguliers ont provoqué des réactions à cellules géantes (1).

La réaction granulomateuse et les cellules inflammatoires disséminées, ont régressé dans le temps pour laisser place à un tissu parfaitement stabilisé et cicatrisé. Ces observations ont été affirmés, après implantation des matériaux inertes et très stables, l'alumine et la zircone, au niveau des muscles paravertébraux de rats pour une période de douze semaines (7).

La propriété majeure des phosphates tricalciques est leur biorésorption associée à une bioréactivité au contact des tissus vivants (32, 46). Après implantation de phosphates tricalcique dans les fémurs et les muscles para-vertébraux de chiens, on constate que la biodégradation du phosphates tricalcique est plus rapide au niveau du tissu osseux (27).

La diminution du volume des billes de phosphate tricalcique et la diminution de la concentration de calcium à la surface des billes sont des preuves que le site permet d’observer les mêmes réactions que dans les sites standardisés.

Les implants n'ont pas été colonisés, ceci peut être attribué au diamètre insuffisant des pores, car pour une colonisation cellulaire rapide le diamètre souhaité doit être au minimum compris entre 50 micromètres et 150 micromètres (9), or comme nous l'avons cité le diamètre maximum des pores présents dans les billes de phosphate tricalcique implantées est de  50 micromètres.

Ce modèle expérimental confirme les propriétés du phosphate tricalcique. La résorbabilité modulée du matériau, compensée par une activation cellulaire périphérique, situe l'intérêt de ce site d’implantation. La dissolution complète du  phosphate tricalcique n'est pas observée dans nos résultats, ceci est vraisemblablement liée au mode d'usinage des billes, nous n'avons pas utilisé au cours de la préparation des billes des produits dégradables pour laisser des pores de diamètres suffisants.


= Conclusion =

La zone sous capsulaire rénale nous a permis d'observer des phénomènes rapportés par d'autres auteurs au niveau des site différents. Nous avons mis en évidence les propriétés du phosphate tricalcique grâce aux coupes histologiques des zones d'implantation après un mois, deux mois, trois mois et six mois.
 
Aux questions que nous pouvions nous poser au départ nous pouvons répondre :
- l'animal choisi peut être une proposition pour commencer d'autres travaux sur des animaux plus évolués tel le chien, le mouton le porc etc. ;
- la structure du site d'implantation associée aux fonctions de l'organe et à son caractère très réactogène sont des arguments amplement suffisants pour indiquer un tel choix ;
- la présence de tissu collagène est le résultat des propriétés inductrices du phosphate tricalcique mises en évidence par de nombreux auteurs ( 27, 40, 46).

Trente deux animaux ont été opérés, puis sacrifiés, par groupe de 8, à 1, 2, 3 et 6 mois, pour examen macroscopique des reins et des tissus avoisinants, suivi du prélèvement des organes pour l'étude histologique en microscopie optique et de l'extraction des implants pour examen au microscope électronique à balayage. Les suites opératoires ont été normales compte tenu de l'augmentation du poids des animaux et de la bonne cicatrisation des tissus dès les premiers jours.
 
Les reins ont été traités de manière identique par les techniques histologiques classiques, l'examen des coupes au microscope optique confirme des résultats globaux identiques sur toutes les lames. Nous avons noté l'absence de réaction de rejet, l'absence d'encapsulation semblable à celle qui isole un corps étranger. Dans tous les cas, la tolérance tissulaire est confirmée par la normalité des cellules parenchymateuses et la continuité de la capsule rénale au voisinage immédiat et à distance de l'implant.

La microanalyse met en évidence une diminution de la concentration en calcium à la surface des implants au terme de l'expérimentation.

Nous pouvons conclure que le protocole arrêté, joint à l'exploitation d'un site original d'implantation constitue un modèle expérimental. Comparativement aux autres expérimentations, les résultats obtenus dans notre travail sont satisfaisants et constituent un point de départ pour d'autres travaux utilisant d'autres moyens d'investigation.

La zone sous capsulaire rénale  permet de retrouver facilement l'implant, les moyens d'investigations étant en plein progrès il peut paraître intéressant d'analyser l'interface biomatériau-tissu dans le temps au niveau de la zone sous capsulaire rénale d'un animal tout en le conservant vivant.


= Bibliographie =

# ALLABOUCH A., COLAT PARROS J., SALMON R., MEUNIER J.M. .- ‘’Biocompatibility of some Materials Used in Dental Implantology’’: Histological Study’.Colloïds and SurfacesB:Biointerfaces,1,1993:323- 329.
# ALBREKTSSON T., LEKHOLM U. .- Biocompatibility of the Implant Materials. The Dental Clinic of North America, 33, 1989 : 547-549.
# Altermatt S., Schwöbel m., Pochon J.P. .- Operative Treatment of Solitary Bone Cysts with Tricalcium Phosphate Ceramic. Eur. J. Pediatr. Surg., 2, 1992 : 180-182
# BURDAIRON G. .- Abrégé des Biomatériaux Dentaires. Éditions Masson, Paris, 1990.
# BAQUEY C. DUCASSOU D. .- Matériaux d'origine biologique utilisés comme biomatériaux. Biomat, BORDEAUX 1986.
# CHOW L.C. .- Calcium Phophate Materials : Reactor Response. Advance in Dental Research, 2, 1988 : 181-184.
# Christel P., Meunier A., Heller M. .- ‘’Mechanical Properties and Short-Term In-Vivo Evaluation of Yttrium-Oxide-Partially- Stabilized Zirconia’’. Journal of Biomedical Materials Research, 23, 1989 : 45-61.
# Daculsi G., PASSUTI M., Le NIHOUANNEN J.C., Kerebel B. .- ‘’Étude comparative de céramiques bioactives en phosphate de calcium après implantation en site osseux spongieux chez le chien’’. Revue de Chirurgie Orthopédique, 75, 1989 : 65-71.
# Daculsi G., Passuti N. .- ‘’Effect of the Macroporosity for Osseous Substitution of Calcium Phosphate Ceramics’’. Biomaterials, 11, 1990 : 86-87.
# de GROOT K. .- Medical Application of Calcium Phosphate Bioceramics. Journal of the Ceramic Society of Japan, 99, 10, 1991 : 943-953.
# DRIESSENS F.C, RAMSELAAR MA., VAN MULLEM P.J. .- ‘’Chemical Reactions of Calcium Phosphate Implants after Implantation In Vivo’’. Journal of Materials Science,Materials in Medicine,3,1992:413- 417
# DUCASSOU D., MASSIAH A. .- Matériaux nouveaux et biocompatibilité. Biomat,Codemat,Bordeaux, 1984.
# Ducheyne P., BEIGHT J., CUCKLER J., EVANS B., Radin S. .- ‘‘Effect of Calcium Phosphate Coating Characteristics on Early Post-Operative Bone Tissue Ingrowth’’. Biomaterials, 11, 1990 : 531-539.
# EXBRAYAT P., COUBLE M.L., MAGLOIRE H., HARTMANN D.J. .- Evaluation of the Biocompatibility of a Ni-Cr-Mo Dental Alloy with Human Gingival Explant Culture in Vitro:Morphological Study, Immunodectection of Fibronectin, and Collagen Production. Biomaterials, 8, 1987 : 385-392.
# FARRIS E.J., GRIFFITH J.Q. .- The Rat in Laboratory Investigation. Lippincott Company, Philadelphia, Montreal, London, 1, 1942.
# Gregoire G., GUYONNET J.J. .- Evaluation de la biocomptabilité des matériaux utilisés en odontologie : moyens et protocoles d'expérimentation. EMC., Odontologie, 23063 G10, 1991 : 6p.
# Gregoire G., GUYONNET JJ. .- Biocomptabilité des différents matériaux utilisés en odontologie. EMC., Odontologie, 23063 G15, 1993 : 6p.
# Grignon G.  .- ‘’Cours d’histologie’’. Ellipses, éditions, Paris 1996.
# HAMAD M., HEUGHEBAERT J.C. .- ‘‘The Growth of Whitlockite’’.Journal of Crystal Growth, 79,1986 : 192-197.
# HARMAND M.F. .- ‘’Evaluation &quot;in vitro&quot; des biomatériaux à usage odontologique à l'aide de cellules d'origine humaine’’. Actualités en Biomatériaux. Éditions Romillat, 1993 : 273-277.
# HEUGHEBAERT J.C., HEUGHEBAERT M., ROUX P., BONEL G. .- ‘’Biocéramiques à base de phosphate de calcium’’. Bulletin de la Société Chimique de France, 4, 1985 : 528-531.
# HEUGHEBAERT J.C., LACOUT J.L. .- ‘’Composition, Structure and Properties of Calcium Phosphates of Biological Interest. Biological and Biomechanical’’. Performance of Biomaterials, Elsevier Science Publishers, 1986 : 9-14.
# Hollinger J.O., Schmitz J.P., Mizgala J.W. Hassler C. .- ‘’An Evaluation of Two Configurations of Tricalcium Phophate for Treating Craniotomies’’. Journal of Biomedical Materials Research, 23, 1989 : 17-29.
# Hyakuna K., YAMAMURO T., KOTOURA Y., OKA M., Kokubo T. .- ‘’The Influence of Calcium Phosphate Ceramics and Glass-Ceramics on Cultured Cells and Their Surrounding Media’’. Journal of Biomedical Materials Research, 23, 1989 : 1049-1066.
# Jarcho M. .- Biomaterial Aspects of Calcium Phosphates. Dental Clinics of North America. 1986, 30 : 25-45.
# Klein C.P.A.T., Patka p., den Hollander W. .- ‘’Macroporous Calcium Phosphate Bioceramics in Dog Femora:  Histological Study of Interface and Biodegradation’’. Biomaterials, 10, 1990 : 59-62.
# Klein C.P.A.T., de BLIECK-HOGERVORST JA.,  de Groot K. .- ‘’Studies of the Solubility of Different Calcium Phosphate Ceramic Particles In Vitro’’. Biomaterials, 11, 1990 : 509-512.
# Lacout J.L. .- ‘’Calcium Phosphate as Bioceramics’’. Biomaterials, Hard Tissue Repair and Replacement, Elsevier Science Publishers, 1992: 81-95.
# Le Geros R.Z. .- Calcium Phosphate Materials in Restorative Dentistry. Advance in Dental Research, 2, 1, 1988 : 164-180.
# Lemons J., Natiella J. .- Biomaterials, Biocompatibility, and Peri-Implant Considerations. Dental Clinics of North America, 30, 1, 1986 : 3-23.
# MEUNIER J.m. .- ‘’Étude expérimentale par la technique des greffes hypophysaires et l'administration de réserpine de la régulation hypothalamique chez la rate’’. Thèse Doctorat Es-Sciences, Bordeaux , 1961.
# MUSTER D., CHAMPY M. .- Le problème d'interface os-biomatériaux. Actualités Odonto-Stomatologiques, 121, 1978 : 109-122.
# Muster D. .- ‘’Biomatériaux et biomatériels en chirurgie osseuse et dentaire (Première partie)’’. EMC. (Paris- France), Stomatologie et Odontologie, 22014 F10, 1993 : 27p.
# Muster D. .- ‘’Biomatériaux et biomatériels en chirurgie osseuse et dentaire (Deuxième partie)’’. EMC. (Paris- France), Stomatologie et Odontologie, 22014 F15, 2, 1993 : 26p.
# NAIM S., G. GREGOIRE, R. SALMON, J.M. MEUNIER.. .- &quot;Implantation ou greffe sous-capsulaire rénale chez le rat&quot;. Journal de Biomatériaux Dentaire, 9, 1994 :149-152.
# NAIM S. .- &quot;Implantation d'un phosphate tricalcique sous la capsule rénale du rat&quot;.Thèse Doctorat d’Université en Sciences  Odontologiques, Paul Sabatier,   Toulouse, 1994.
# NAIM S., G. GREGOIRE, R. SALMON, J.M. MEUNIER.. .- &quot;Implantation d'un phosphate tricalcique sous la capsule rénale du rat&quot;. Journal des Biomatériaux Dentaire, 10, 1995 :117-124 .
# NAIM S., G. GREGOIRE, R. SALMON, J.M. MEUNIER.. .- Analyse d'un phosphate tricalcique avant et après implantation. Journal des Biomatériaux Dentaires, 11, 1996 :115-128.
# NAIM S., G. GREGOIRE, R. SALMON, J.M. MEUNIER.. .- ‘’Importance de l’état de surface au cours des tests de biocompatibilité’’. Journal des Biomatériaux Dentaires, 13, 1998 : 89-106.
# RAMSELAAR MA., DRIESSENS F.C, KALK W., VAN MULLEM P.J. .- ‘’Biodegradation of Four Calcium Phosphate Ceramics; In Vivo Rates and Tissue Interactions’’. Journal of Materials Science, Materials in Medicine,2,1991: 63-70.
# Rey C. .- ‘’Calcium Phosphate Biomaterials and Bone Mineral’’. Differences in Composition, Structures and Properties’’. Biomaterials, 11, 1990 : 13-15.
# SAFFAR J.L., COLOMBIER M.L., DETIENVILLE R. .- ‘’Bone Formation in Tricalcium Phosphate-Filled Periodontal Intrabony Lesions. Histological Observations in Human’’. Journal of  Periodontology, 61, 1990: 209-216.
# SANDHAUS S. .- Nouveaux aspects de l'implantologie, l'implant CB S. Lausanne 1969, Éditions Medica 1975.
# STANFORD J.W. .- Future of Materials and Materials Research. Advance in Dental Research, 2,1, 1988 : 187-192.
# STEVENS A., LOWE J. .-  ‘’Histologie’’. Édition Pradel, 1993.
# WAGNER W., WAHLMANN U.W. HEIDEMANN D. .- ‘’Tissue Reaction and Biodegradation Behaior of Various Calcium Phosphate Materials. Biomaterials and Clinical Applications’’. Elsevier Science Publishers, 1987 : 609-614.
# Williams D.F. .- Fundamental Aspects of Biocompatibility. CRC, Series in Biocompatibility. CRC Press Inc. 1981.</text>
      <sha1>fbkbpfxewsol8nhfl3hhuffpcjgvr4i</sha1>
    </revision>
  </page>
  <page>
    <title>Plantes messicoles de l'Avesnois/Atlas des plantes messicoles/Présentation des espèces secondaires/Allium vineale L.</title>
    <ns>0</ns>
    <id>47844</id>
    <revision>
      <id>684254</id>
      <parentid>674946</parentid>
      <timestamp>2022-08-27T17:59:42Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="23424" xml:space="preserve">{{Taxobox début | végétal | Ail des vignes &lt;br /&gt;ou « Oignon bâtard » |Allium vineale1.jpg| ''Allium vineale''|Inflorescence | classification=Cronquist }}
{{Taxobox | sous-règne | Tracheobionta }}
{{Taxobox | division | Magnoliophyta }}
{{Taxobox | sous-division | Spermatophytina }}
{{Taxobox | classe | Liliopsida }}
{{Taxobox | sous-classe | Liliidae }}
{{Taxobox | ordre | Liliales }}
{{Taxobox | famille |Liliaceae}}
{{Taxobox | genre | Allium }}
{{Taxobox taxon | végétal | espèce | ''Allium vineale'' | [[:w:Carl von Linné|L.]], [[:w:1753|1753]]  }}
{{Taxobox phylogénie bandeau | végétal | classification=APGIII}}
{{Taxobox | clade | Angiospermes }}
{{Taxobox | clade |  Monocotes }}
{{Taxobox | ordre | Asparagales}}
{{Taxobox | famille | Amaryllidaceae}}
{{Taxobox | sous-famille | Allioideae }}
{{Taxobox | genre | Allium}}
{{Taxobox fin}}

[[File:Allium vineale02.jpg|thumb|left|Ail des vignes (Fructification)]]
[[File:Ail des vignes zoom.jpg|thumb|left|Aspect (« chaume ») de l'[[:w:Infrutescence|infrutescence]], mi-juillet (13 juillet 2007)]]
&lt;strong&gt;'''Ail des vignes'''&lt;/strong&gt;

&lt;br /&gt;[[w:en:Allium_vineale|Wild Garlic]] ou  [[w:en:Allium_vineale|Crow Garlic]] pour les anglophones 
&lt;br /&gt;[[w:nl:Allium_vineale|Kraailook]] pour les néerlandophones
&lt;br /&gt;Baragane (dans le Sud-Ouest de la France)

Famille des [[:w:Amaryllidaceae|Amaryllidacées]]

==Description==
C'est une plante [[:w:Plante vivace|vivace]] de 30 à 80 cm de hauteur, qui dégage une odeur alliée quand on la froisse ou l'écrase. 

Elle est issue d'un bulbe en forme d'œuf, de 1 à 2 cm de diamètre,  protégé par une couche brunâtre. &lt;br /&gt;Souvent, le bulbe produit de nombreux bulbilles souterrains, qui sont l'un des organes de reproduction [[:w:Reproduction asexuée|asexuée]] (clonale) de cette espèce. 
&lt;br /&gt;Du bulbe sort une tige cylindrique, pleine, glabre. Cette tige porte des feuilles jusqu'au milieu ; 
&lt;br /&gt;Les feuilles sont subcylindriques, creuses et glabres, à sillon étroit en dessus, glauques. Elles mesurent de 10 à 20 cm.
&lt;br /&gt;Les fleurs, estivales et peu nombreuses sont rose-pâle à blanchâtres, parfois violacées ou verdâtre&lt;ref name=NewEngland/&gt;, disposées en [[:w:Ombelle|ombelle]]s simples. &lt;br /&gt;L'ombelle porte des [[:w:Bulbille|bulbilles]], généralement plus nombreux que les fleurs (il arrive souvent qu'il n'y ait que des bulbilles ; on dit qu'elles sont « bulbillifères » ) ; Une [[:w:spathe|spathe]] univalve, ovale-aiguë ; en tête globuleuse serrée, souvent toute ; pédicelles renflés-globuleux sous la fleur, 4-5 fois plus longs qu'elle ; périanthe en cloche ; &lt;br /&gt;[[:w:étamine|étamine]]s saillantes, les 3 intérieures à filets trifides, la pointe médiane plus courte ; capsule à sommet ombiliqué. Les graines sont noires, aplaties sur un côté et à texture ridée&lt;ref name=NewEngland/&gt;.

== Écologie ==
* &lt;strong&gt;'''[[w:fr:Habitat|Habitat]] / [[w:fr:Biotope|Biotope]] :''' &lt;/strong&gt; &lt;br /&gt;C'est une plante qui apprécie les lieux sablonneux, cultivés (messicole), les lieux incultes et friches vivaces rudérales pionnières, mésoxérophiles. On pouvait autrefois la trouver dans presque toute la France métropolitaine et en Corse. Certaines populations sont trouvées dans les prairies, pelouses voire dans certaines ripisylves ou forêts alluviales, où des bulbilles ont pu être apportées par les crues.&lt;br /&gt;(à compléter)
* &lt;strong&gt;'''[[:w:Phytosociologie|Phytosociologie]] :''' &lt;/strong&gt; &lt;br /&gt;[[:w:Syntaxon|Syntaxon]] ; ''Gageo pratensis - Allion schoenoprasi'' Passarge 1964&lt;br /&gt;(à compléter)
* &lt;strong&gt;'''[[:w:Interactions durables|Interactions durables]]''' :&lt;/strong&gt;&lt;br /&gt;Une étude&lt;ref name=Mycorrhizae2012/&gt; récente (2012) a cherché - de l'ail des vignes à expérimentalement mesurer l'effet des variations de teneur en phosphore, à tous les stades de développement  sur ses associations mycorhiziennes, sachant que dans cette relation, un déséquilibre induit par l'affaiblissement d'un des partenaires peut faire glisser l'association vers le parasitisme (le long d'un continuum mutualisme-parasitisme). L'étude s'est intéressée à l'influence du taux de [[:w:Phosphore|phosphore]] (l'un des nutriments apportés par les engrais agricoles) du sol sur la réponse de Allium vineale à la mycorhization, aux différents stades de développement de la plantes, en examinant aussi les impacts de l'association symbiotique avec un champignon sur la fécondité des plantes et l'allocation relative des ressources vers les trois différents modes de reproduction de cette espèce. Les résultats ont confirmé qu' ''A. vineale'' profite bien de  l'association symbiotique, mais avec un impact variant fortement selon le stade de développement : On constate d'abord une inhibition de la croissance durant le premier mois, qui sera rattrapé en 15 mois ; avec ''in fine'' un bulbe plus gros (quel que soit le taux de phosphore du sol) chez les pieds mycorhizés&lt;ref name=Mycorrhizae2012/&gt;. &lt;br /&gt;Dans un sol pauvre en phosphore, les ails mycorhyzés produisent plus de bulbilles ainsi que des clones plus gros que ne le font les plantes non-mycorhizées. &lt;br /&gt;Toutefois, la mycorhization ne modifie pas la répartition relative des ressources entre les trois modes de reproduction&lt;ref name=Mycorrhizae2012/&gt;. Quand on augmente le taux de phosphore du sol, l'effet global des mycorhizes passe d'une situation bénéfique à neutre, l'avantage maximal de l'association symbiotique apparaissant dans les sols les plus pauvres en phosphore&lt;ref name=Mycorrhizae2012&gt;Margaret L. Ronsheim, ''The Effect of Mycorrhizae on Plant Growth and Reproduction Varies with Soil Phosphorus and Developmental Stage'' ; The American Midland Naturalist (édité par la &quot;University of Notre Dame&quot;) 167(1) ; pages 28 à 39. Jan 2012 doi:http://dx.doi.org/10.1674/0003-0031-167.1.28 ([http://www.bioone.org/doi/abs/10.1674/0003-0031-167.1.28 Résumé])&lt;/ref&gt;.
* &lt;strong&gt;'''[[w:fr:Aire de répartition|Distribution]] :''' &lt;/strong&gt; &lt;br /&gt;C'est une espèce de l'Ouest de l'[[:w:Eurasie|Eurasie]] qu'on trouve jusqu'en [[:w:Syrie|Syrie]]&lt;ref name=NewEngland/&gt;.
* &lt;strong&gt;'''[[w:fr:Biologie|Biologie]] :''' &lt;/strong&gt;  
** '''Organes reproducteurs'''. Cette espèce [[:w:Bisanuelle|bisanuelle]] dispose de trois moyens complémentaires de reproduction, avec 1) une reproduction asexuée par production de bulbilles souterrains dispersés par des animaux, ou sur les sols cultivés par un hersage ou un labour doux. 2) une reproduction sexuée aérienne via les fleurs ; 3) une production de bulbilles aériennes tombant au sol près de la plante en automne, ou éventuellement tombant dans l'eau ou emportée par le ruissellement vers des fossés, plans d'eau ou cours d'eau proche. Les bulbilles flottent et peuvent dériver pour aller s'enraciner à distance ; Souvent, ces capitules contiennent - avec les fleurs- des bulbilles végétatives (de la taille d'un grain de blé, lisse et pointues, terminée par une feuille fragile). Parfois la plante produit une tête entière de bulbilles aériennes&lt;ref name=NewEngland/&gt;{{,}}&lt;ref&gt;Fernald, M.L. (1950), ''Gray's Manual of Botany'' ; 8th edition ; American Book Company, New York. P.431&lt;/ref&gt;{{,}}&lt;ref&gt;Gleason, H.A. and A.C. Cronquist (1991), ''Manual of Vascular Plants of the Northeastern United States and Adjacent Canada'' ; 2nd ed.  New York Botanical Garden, Bronx, New York. ; p. 832&lt;/ref&gt;{{,}}&lt;ref&gt;Holmgren, N.H. (1998), ''Illustrated Companion to Gleason and Cronquist's Manual''.  New York Botanical Garden, Bronx, New York ; p. 790 &lt;/ref&gt;{{,}}&lt;ref&gt;Magee, D.W and H.E. Ahles. (1999)  ''Flora of the Northeast. University of Massachusetts'' ; Press, Amherst. ; p. 342&lt;/ref&gt;{{,}}&lt;ref&gt;Peterson, R.T. and M. McKenny. (1968), ''A field Guide to Wildflowers of Northeastern and North-central North America'' ; Houghton Mifflin, Boston ; p. 296&lt;/ref&gt;.
** '''Répartition des sexes''' :  [[w:fr:Glossaire botanique|hermaphrodite]]
** '''Type de pollinisation''' :  [[w:fr:Glossaire botanique|entomogame, autogame]] (à vérifier; y a t il des pollinisateurs spécifiques ? si oui, ils doivent être présent en Amérique du Nord où la plante s'est rapidement multipliée après son introduction)
** '''Période de floraison''' :  Juin-aout (voire jusqu'en septembre parfois)
** '''Type de fruit''' :  [[w:fr:Glossaire botanique|akène]] (à compléter)
** '''Mode de dissémination''' : [[:w:Barochore|barochore]] et parfois [[:w:hydrochore|hydrochore]]. Des auteurs ont notés que les fourmis semblaient apprécier ces graines, ce qui pourrait évoquer qu'elles puissent aussi jouer un rôle dans leur propagation (à confirmer).

==Aspects historiques==
C'est une espèce qui a probablement été depuis longtemps utilisée comme condiment par certaines populations eurasiatiques.
&lt;br /&gt;En France, cet ail n'a pas toujours été considéré comme une simple adventice, voire comme une mauvaise herbe, mais autrefois comme un ail sauvage &lt;ref name=encycloMed1790&gt;Panckoucke (1790), dans son [http://books.google.fr/books?id=NAuqdWbe8mcC&amp;lpg=PA45&amp;ots=BJmEotxV-L&amp;dq=%C3%A9tymologie%20Allium%20vineale&amp;hl=fr&amp;pg=PA45#v=onepage&amp;q=%C3%A9tymologie%20Allium%20vineale&amp;f=false Encyclopédie méthodique ; Médecine], Tome second (par ordre de matières, Volume 141), avec Google livre, consulté 2012-02-12&lt;/ref&gt; et comme une plante d'intérêt économique, utilisé dans l'alimentation et en [[:w:Médecine vétérinaire|Hygiène vétérinaire]] ; Selon la ''« Phitographie économique de la Lorraine »'' écrite par M. TVillemef, dans s''l'Ail des vignes peut être employé aux mêmes usages que l'ail cultivé, &amp; il sert encore à la nourriture de quelques animaux ; les vaches, les moutons, &amp; les chèvres parfissent le manger avec plaisir. On a observé que les alouettes qui en mangent sont un mets fort délicat , tandis au contraire que les vaches qui en ont été nourries, donnent du lait &amp; du beurre d'un goût fort &amp; détestable. II plaît aussi aux souris &amp; aux taupes.'' (art. écrit par M. Huzard&lt;ref name=encycloMed1790/&gt;). 
&lt;br /&gt;Comme l'[[:w:Ail des ours|ail des ours]] il donne un goût d'ail au lait, qui gêne les usages de type sucrés, mais sans excès pouvait agréablement parfumer le fromages et le beurre, les purées et certains plats faits avec du lait.

Cet ail sauvage a régressé en Europe avec l'Agriculture intensive, mais est aujourd’hui présente en Afrique du nord ([http://www.ville-ge.ch/musinfo/bd/cjb/africa/details.php?langue=fr&amp;id=155954 au Maroc et en Algérie] ; introduite ? dans un passé plus ou moins récent ?) et abondamment présente en Amérique boréale où elle a été introduite à une date indéterminée (avant les années 1870) ; On la trouve maintenant aux États-Unis&lt;ref&gt;USDA, NRCS.  2001.  ''The PLANTS Database, Version 3.1.'' ([http://plants.usda.gov USDA]) ; National Plant Data Center, Baton Rouge, LA 70874-4490 USA.&lt;/ref&gt; de l'[[:w:État de Washington|État de Washington]] à la [[:w:Californie|Californie]] le long de la côte Ouest et du Maine à la Floride et à l'ouest du Nebraska, sur la côte Est&lt;ref name=NewEngland/&gt;. Elle est aussi présente au Canada. Elle aurait pu être involontairement importée avec des graines, ou avec des déchets de [[:w:Ballast|ballast]], voire intentionnellement apporté d'Europe comme plante condimentaire par des colons. 
&lt;br /&gt;On l'a signalé dans le [[:w:Connecticut|Connecticut]] en [[:w:1873|1873]] puis en [[:w:1892|1892]] dans le [[:w:New-Jersey|New-Jersey]] parmi les « [[:w:Mauvaise herbe|mauvaises herbes]] » des cultures. Fernald en [[:w:1950|1950]] la jugeait ''« trop abondante »'' ; Elle est maintenant présente dans toute la [[:w:Nouvelle-Angleterre|Nouvelle-Angleterre]] où elle peut avoir localement un comportement « [[:w:Plante envahissante|envahissant]] », voire [[:w:Invasive|invasif]]&lt;ref name=NewEngland&gt;[http://nbii-nin.ciesin.columbia.edu/ipane/icat/browse.do?specieId=98 Atlas des plantes invasives de Nouvelle-Angleterre], consulté 2012-02-12&lt;/ref&gt;, y compris dans quelques zones naturelles où elles peuvent concurrencer les espèces autochtones&lt;ref name=NewEngland/&gt;.
(à compléter pour l'Avesnois ; cf usages médicinaux, vétérinaires ou autres...)

==Étymologie==
''Allium'' est une variante de ''[http://www.lexilogos.com/latin/gaffiot.php?p=102 alium]'', désignant l'ail en latin.
''Vineale'' vient du latin ''[http://www.lexilogos.com/latin/gaffiot.php?p=1679 vinea]'', la vigne, aux pieds de laquelle elle pouvait autrefois être commune, étant donné leur affinité pour les mêmes sols pauvres ou drainant et ensoleillés.

==Génétique==
Selon les données expérimentales disponibles (nord américaines), bien que disposant de plusieurs modes reproductifs, la plasticité phénotypique et reproductive de l'espèce face à l'allocation des ressources semble réduite, laissant penser que ces plantes sont ''« peu susceptibles de changer le mode de reproduction en réponse à la disponibilité des nutriments »&lt;ref name=RonsheimBever2000&gt;Margaret L. Ronsheim et James D. Bever, ''[http://www.amjbot.org/content/87/12/1769.full.pdf+html Genetic variation and evolutionary trade-offs for sexual and asexual reproductive modes in Allium vineale (Liliaceae)]''(American Journal of Botany ; publié par la &quot;Botanical Society of America, Inc&quot;. 2000;87:1769-1777 ([http://www.amjbot.org/content/87/12/1769.short Résumé])&lt;/ref&gt;''.
&lt;br /&gt;Néanmoins, sa réussite dans sa ''« conquête des États-Unis »'' montre qu'en l'absence de prédateurs ou inhibiteurs, elle a de bonnes capacités de dispersion.

== Statuts et conservation ==
L'ail des vignes n'est pas [[w:w:Espèce protégée|protégée]] en France, ni en Belgique.
&lt;br /&gt;Cette espèce peut être localement éteinte ou menacée dans son aire naturelle de répartition. 

Plusieurs facteurs connus de régression de l'espèce sont : 
* l'[[:w:Eutrophisation|eutrophisation]], la [[:w:Dystrophisation|dystrophisation]] du milieu ;
* l'intensification et l'homogénéisation de l'agriculture ;
* et dans certaines circonstances, une possible prédation accrue sur les bulbes (qui ont une capacité de dispersion limitée).

Les relations entre [[:w:Métapopulation|métapopulations]] et [[:w:Biologie des population|population]]s, et les capacités de dispersion de l'Ail des vignes sont assez mal connues. 
&lt;br /&gt;Elles ont notamment été étudiées par Margaret L. Ronsheim&lt;ref name=Ronsheim1994/&gt; dans les années 1990 en comparant ses trois types de [[:w:Propagule|propagules]] ; les graines issues de la reproduction sexuelle (qui assurent le maintien d'une [[:w:Diversité génétique|diversité génétique]] au sein des populations, les bulbilles aériennes issues d'une reproduction asexuée, et la duplication &quot;souterraine&quot; des individus. 
Il s'agissait notamment essayer de comprendre les facteurs pouvant favoriser l'un ou l'autre de ces modes reproductifs et leurs force et faiblesse en termes de sélection naturelle. Dans ce cadre, on a étudié trois traits écologiques des propagules aériens : les « patrons » de dispersion, les taux de prédation, et la longévité des propagules. &lt;br /&gt;Les graines tombent à proximité du pied-mère, dans la même zone que les bulbilles ; elles font l'objet de plus de prédation que les bulbilles, mais elles germent occasionnellement à 10-30 cm plus loin du pied-mère que les bulbilles. 
&lt;br /&gt;Ronsheim a constaté que infrutescences (via leurs bulbilles) pouvaient parfois former une unité de dispersion&lt;ref name=Ronsheim1994/&gt;.
&lt;br /&gt;Les taux de prédation sont significativement plus élevés pour les [[:w:Graine|semence]]s que pour les bulbilles, mais selon Ronsheim (1994), la densité des propagules sur le terrain n'a eu aucun effet sur les taux d'enlèvement. Les graines et les bulbilles enterrés sur place restent viables un an au plus (de 1 à 5 ans selon d'autres sources&lt;ref name=NewEngland/&gt;), mais les graines stockées ''ex-situ'' (en laboratoire) pour un maximum de 3 ans sont plus nombreuses à rester viable que les bulbilles&lt;ref name=Ronsheim1994/&gt;. 
&lt;br /&gt;Globalement et par rapport à ce que l'on constate pour d'autres espèces à plusieurs formes de propagules (à « ''propagules dimorphes'' »), il semble chez l'ail des vignes y avoir  peu de différences entre les semences et bulbilles. Margaret L. Ronsheim n'a en outre pas observé les différences prédites par les modèles pour les conditions nécessaires au maintien de la production de propagules hétéromorphes. &lt;ref name=Ronsheim1994&gt;Ronsheim, M. L. 1994. ''Dispersal distances and predation rates of sexualand asexual propagules of Allium vineale L.'' American Midland Naturalist 131: 55–64.&lt;/ref&gt;{{,}}&lt;ref name=RonsheimBever2000/&gt;.

== Propriétés et usages ==
Les feuilles et les bulbilles s'utilisent en [[:w:Condiment|condiment]], comme l'ail cultivé (par exemple pour pour parfumer les [[:w:omelette|omelettes]], ou la « ''[[:w:lamproie|Lamproie]] à la bordelaise'' » dans le Sud-Ouest de la France).
&lt;br /&gt;Comme tous les ails (''Alliums''), il est [[:w:stimulant|stimulant]], [[:w:diurétique|diurétique]], [[:w:expectorant|expectorant]] et [[:w:antiseptique|antiseptique]].
&lt;br /&gt;Concernant l'alimentation, une confusion avec d'autres espèces d'ails est sans danger, aucune n'étant toxique&lt;ref&gt;« ''Guide des plantes sauvages comestibles et toxiques'' », de François Couplan et Eva Styner, coll. Les guides du naturaliste, éd. Delachaux et Niestlé, {{ISBN|978-2-603-00952-9}}.&lt;/ref&gt;

==Espèces proches, confusions possibles ==
En Amérique du Nord, cette espèce peut être confondue avec ''[[:w:Allium canadense|Allium canadense]]'' L. (dit ''oignon sauvage'') dont les feuilles sont plus plates et dures (par rapport aux feuilles rondes et creuses de ''A. vineale'') et poussant de la base au tiers de la tige (alors qu'elles poussent jusqu'à la moitié de la hauteur de la tige chez ''A. vineale'').

== Synonymie :==
&lt;div style=&quot;-moz-column-count:2; column-count:2; -webkit-column-count:2&quot;&gt;
* ''Allium affine'' Boiss. &amp; Heldr., 1859 (CD_NOM=81300)
* ''Allium arvense'' Boreau (CD_NOM=81319)
* ''Allium assimile'' Halácsy, 1904 (CD_NOM=81322)
* ''Allium campestre'' Bubani, 1902 (CD_NOM=81333)
* ''Allium compactum'' Thuill., 1799 (CD_NOM=81351)
* ''Allium cupuliferum'' Regel, 1875 (CD_NOM=618718)
* ''Allium kochii'' Lange, 1864 (CD_NOM=81409)
* ''Allium laxiflorum'' Tausch, 1829 (CD_NOM=81414)
* ''Allium littoreum'' Bertol., 1819 (CD_NOM=81418)
* ''Allium monspessulanum'' Willd. ex Schltdl., 1813 (CD_NOM=81435)
* ''Allium nitens'' Sauzé &amp; Maillard, 1864 (CD_NOM=81450)
* ''Allium parviflorum'' Desv., 1827 (CD_NOM=81469)
* ''Allium purshii'' G.Don, 1827 (CD_NOM=81490)
* ''Allium rilaense'' Panov, 1973 (CD_NOM=81496)
* ''Allium sphaerocephalon'' var. ''compactum'' (Thuill.) Cariot &amp; St.-Lag., 1889 (CD_NOM=143277)
* ''Allium subvineale'' Wendelbo, 1971 (CD_NOM=81526)
* ''Allium tenuiflorum'' Delastre, 1842 (CD_NOM=81529)
* ''Allium vineale subsp. ''affine'' (Boiss. &amp; Heldr.) K.Richt., 1890 (CD_NOM=131221)
* ''Allium vineale'' subsp. ''compactum'' (Thuill.) Berher, 1887 (CD_NOM=131223)
* ''Allium vineale'' subsp. ''cupuliferum ''(Regel) K.Richt., 1890 (CD_NOM=616636)
* ''Allium vineale'' subsp. ''kochii'' (Lange) K.Richt., 1890 (CD_NOM=131224)
* ''Allium vineale'' subsp. ''monspessulanum'' Nyman, 1882 (CD_NOM=131225)
* ''Allium vineale'' var. ''capsuliferum'' W.D.J.Koch, 1890 (CD_NOM=143290)
* ''Allium vineale'' var. ''compactum'' (Thuill.) Boreau, 1857 (CD_NOM=143291)
* ''Allium vineale'' var. ''laxiflorum'' (Tausch) Rouy, 1910 (CD_NOM=143292)
* ''Allium vineale'' var. ''monspessulanum'' (Willd. ex Schltdl.) P.Fourn., 1935 (CD_NOM=143293)
* ''Allium vineale'' var. ''nitens'' (Sauzé &amp; Maillard) Nyman, 1882 (CD_NOM=143294)
* ''Allium vineale'' var. ''nitens'' (Sauzé &amp; Maillard) P.Fourn., 1935 (CD_NOM=143295)
* ''Allium vineale'' var. ''virens'' Boiss., 1882 (CD_NOM=143296)
* ''Allium vineale proles nitens'' (Sauzé &amp; Maillard) Rouy, 1910 (CD_NOM=152691)
* ''Allium vineale'' L. subsp. ''capsuliferum'' (Regel) K.Richt. (CD_NOM=131222)
* ''Getuonis vinealis'' (L.) Raf., 1837 (CD_NOM=100188)
* ''Porrum arenarium'' Rchb., 1830 (CD_NOM=115188)
* ''Porrum vineale'' (L.) Schur, 1853 (CD_NOM=115201)
&lt;/div&gt;
==Photos  &amp; illustrations==
&lt;gallery&gt;
File:Alliumvineale1web.jpg|''Allium vineale'' L
File:Allium vineale01.jpg|''Allium vineale'' L, à Utrecht (Pays-Bas)
File:Allium vineale Pillnitz.jpg|Feuilles  
File:Allium vineale seeds.jpg|Graines (noires, aspect fripé)
&lt;/gallery&gt;

== Pour en savoir plus ==
 
{{Autres projets
 | commons     = Allium vineale
 | wikispecies = Allium vineale
 | wiktionary  = Ciguë des jardins
 | wikipédia = Allium vineale
 | wikiversity = &lt;!-- Wikiversity --&gt;
 | wikisource  = &lt;!-- Wikisource --&gt;
 | wikiquote   = &lt;!-- Wikiquote --&gt;
 | wikinews    = &lt;!-- Wikinews --&gt;
 | meta        = &lt;!-- Metawiki --&gt;
 | outreach    = &lt;!-- Outreach --&gt;
}}

=== Voir aussi ===
&lt;div style=&quot;-moz-column-count:3; column-count:3; -webkit-column-count:3&quot;&gt;
* [[:w:Messicole|Messicole]] (sur Wikipédia)
* [[:w:Apiaceae|Apiaceae]] (sur Wikipédia)
&lt;/div&gt;

=== Liens externes ===
* ({{fr}}) [http://www.cpie-avesnois.org/ CPIE Bocage de l'Avesnois] (Portail Internet)
* ({{fr}}) [http://inpn.mnhn.fr/espece/cd_nom/81544 Fiche espèce de l'Ail des vignes] sur le site de l'INPN (Inventaire national du patrimoine naturel)
* ({{fr}}) [http://inpn.mnhn.fr/source/releve/sourceDonneeDepartement/81544/59 Données disponibles pour le département du Nord] (INPN)

=== Bibliographie ===
* ({{fr}}) François Couplan et Eva Styner, « ''Guide des plantes sauvages comestibles et toxiques'' », coll. Les guides du naturaliste, éd. Delachaux et Niestlé, {{ISBN|978-2-603-00952-9}}.
* ({{en}}) Margaret L. Ronsheim et James D. Bever (2000), ''[http://www.amjbot.org/content/87/12/1769.full.pdf+html Genetic variation and evolutionary trade-offs for sexual and asexual reproductive modes in Allium vineale (Liliaceae)]''(American Journal of Botany ; publié par la &quot;Botanical Society of America, Inc&quot;. 2000;87:1769-1777 ([http://www.amjbot.org/content/87/12/1769.short Résumé]).
* ({{en}}) Ronsheim, M. L. (1996), ''Evidence against a frequency-dependent advantage for sexual reproduction in Allium vineale''. American Naturalist 147: 718–734 ([http://www.jstor.org/pss/2426608 résumé via CrossRef]). 
* ({{en}}) Ronsheim, M. L. (1997), ''Distance-dependent performance of asexual progeny in Allium vineale (Liliaceae)''. American Journal of Botany 84: 1279–1284([http://www.amjbot.org/content/84/9/1279.abstract?ijkey=e1ddbf2888ae169ef1cd5936c08e8e48d8622f79&amp;keytype2=tf_ipsecsha résumé]). 
* ({{en}}) Duchoslav, M. 2001. ''Small-scale spatial pattern of two common European geophytes Allium oleraceum and A. vineale in contrasting habitats''. Biologia 56 (1): 57-62.
(à compléter)

=== Références ===
Une partie du contenu de cet article provient de la page homonyme de Wikipédia, et de la fiche [http://www.tela-botanica.org/eflore/BDNFF/4.02/nn/3276/export/pdf Tela botanica] du taxon.
* [http://erick.dronnet.pagesperso-orange.fr/ Belles fleurs de France2] ; voir ''Allium vineale'' 
* [[w:Tela Botanica|Tela-botanica]], voir ''Allium vineale''  L., 1753   
* [http://www.ars-grin.gov/ GRIN] ;  espèce 2416 ''Allium vineale''  L.  
{{Références|colonnes=2}}

[[Catégorie:Plantes messicoles de l'Avesnois (livre)|Allium vineale L.]]</text>
      <sha1>kqiya8zvjslvmt2ya5vc7ev64n2l9qb</sha1>
    </revision>
  </page>
  <page>
    <title>Plantes messicoles de l'Avesnois/Atlas des plantes messicoles/Présentation des espèces secondaires/Avena fatua L. subsp. fatua</title>
    <ns>0</ns>
    <id>47865</id>
    <revision>
      <id>684307</id>
      <parentid>564459</parentid>
      <timestamp>2022-08-27T18:45:10Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2624" xml:space="preserve">{{Taxobox début | végétal | Folle-avoine | Avena-fatua-20080324.JPG | ''Avena fatua''&lt;br /&gt;Photo : Miwasatoshi| classification=Cronquist }}
{{Taxobox | sous-règne | Tracheobionta }}
{{Taxobox | division | Magnoliophyta }}
{{Taxobox | sous-division | Spermatophytina }}
{{Taxobox | classe | Liliopsida }}
{{Taxobox | ordre | Cyperales }}
{{Taxobox | famille |Poaceae }}
{{Taxobox | genre | Avena }}
{{Taxobox taxon | végétal | espèce | Avena fatua | [[:w:carl von Linné|L.]], [[:w:1753|1753]]  }}
{{Taxobox phylogénie bandeau | végétal | classification=APGIII}}
{{Taxobox | clade | Angiospermes }}
{{Taxobox | clade |  Monocotes }}
{{Taxobox | ordre | Poales }}
{{Taxobox | famille | Poaceae }}
{{Taxobox | genre | Avena }}
{{Taxobox fin}}

[[Image:Aveneae spp Sturm22.jpg|thumb|left|300 px| ''[[:w:Avena fatua|Avena fatua]]'' ; [[:w:Planche botanique|Planche botanique ancienne]] ]]

&lt;strong&gt;'''Folle-avoine'''&lt;/strong&gt;
&lt;br /&gt;([[w:en:Avena_fatua|common wild oat]] pour les anglophones).


==Description==
(à compléter)

== Écologie ==
* &lt;strong&gt;'''[[w:fr:Habitat|Habitat]] / [[w:fr:Biotope|Biotope]] :''' &lt;/strong&gt; &lt;br /&gt;(à compléter)
* &lt;strong&gt;'''[[:w:Phytosociologie|Phytosociologie]] :''' &lt;/strong&gt; &lt;br /&gt;(à compléter)
* &lt;strong&gt;'''[[w:fr:Aire de répartition|Distribution]] :''' &lt;/strong&gt; &lt;br /&gt;(à compléter)
* &lt;strong&gt;'''[[w:fr:Biologie|Biologie]] :''' &lt;/strong&gt; &lt;br /&gt;(à compléter)

==Aspects historiques==
(à compléter)

==Étymologie==
(à compléter)

==Génétique==
(à compléter)

== Statuts et conservation ==
(à compléter)

== Propriétés et usages ==
(à compléter).

==Espèces proches, confusions possibles ==
(à compléter)

== Synonymie :==
(à compléter)

==Photos  &amp; illustrations==
(à compléter)

== Pour en savoir plus ==
 
{{Autres projets
 | commons     = Aethusa cynapium
 | wikispecies = Aethusa cynapium
 | wiktionary  = Ciguë des jardins
 | wikipédia = Aethusa cynapium
 | wikiversity = &lt;!-- Wikiversity --&gt;
 | wikisource  = &lt;!-- Wikisource --&gt;
 | wikiquote   = &lt;!-- Wikiquote --&gt;
 | wikinews    = &lt;!-- Wikinews --&gt;
 | meta        = &lt;!-- Metawiki --&gt;
 | outreach    = &lt;!-- Outreach --&gt;
}}

=== Voir aussi ===
&lt;div style=&quot;-moz-column-count:3; column-count:3; -webkit-column-count:3&quot;&gt;
* [[:w:Messicole|Messicole]] (sur Wikipédia)
* [[:w:Apiaceae|Poaceae]] (sur Wikipédia)
&lt;/div&gt;

=== Liens externes ===
* [http://www.cpie-avesnois.org/ CPIE Bocage de l'Avesnois] (Site Internet)

=== Bibliographie ===
* {{fr}}(à compléter)

=== Références ===
{{Références|colonnes=2}}

[[Catégorie:Plantes messicoles de l'Avesnois (livre)|Avena fatua L. subsp. fatua]]</text>
      <sha1>1ik5jdwl11gjh4jowq0o11cbgu42vxg</sha1>
    </revision>
  </page>
  <page>
    <title>Plantes messicoles de l'Avesnois/Atlas des plantes messicoles/Présentation des espèces/Lithospermum arvense L. subsp. arvense</title>
    <ns>0</ns>
    <id>48074</id>
    <revision>
      <id>684272</id>
      <parentid>564484</parentid>
      <timestamp>2022-08-27T18:13:12Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="153" xml:space="preserve">&lt;strong&gt;'''grémil des champs'''&lt;/strong&gt;
&lt;br/&gt; (corn gromwell ou field gromwell pour les anglophones, ruw pazelzrad pour les Néerlandais)


{{AutoCat}}</text>
      <sha1>24e8yaq9wkry5vstwj12wdkjcipqtlk</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Tableau des mots réservés</title>
    <ns>0</ns>
    <id>48617</id>
    <revision>
      <id>684292</id>
      <parentid>683046</parentid>
      <timestamp>2022-08-27T18:28:49Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6576" xml:space="preserve">&lt;noinclude&gt;
{{Python}}
[[Catégorie:Mots réservés]]
{{Autres projets|v=Python/Tableau des commandes}}
&lt;/noinclude&gt;

== Les mots clés ==
{| class=&quot;wikitable&quot; |
|+ Liste des mots réservés
|-
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;and&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;as&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;assert&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;break&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;class&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;continue&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;def&lt;/syntaxhighlight&gt;
|width=&quot;12%&quot;|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;del&lt;/syntaxhighlight&gt;
|-
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;elif&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;else&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;except&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python&quot; inline&gt;exec&lt;/syntaxhighlight&gt; *
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;finally&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;for&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;from&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;global&lt;/syntaxhighlight&gt;
|-
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;if&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;import&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;in&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;is&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;lambda&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;not&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;or&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;pass&lt;/syntaxhighlight&gt;
|-
|&lt;syntaxhighlight lang=&quot;python&quot; inline&gt;print&lt;/syntaxhighlight&gt; *
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;raise&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;return&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;try&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;while&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;with&lt;/syntaxhighlight&gt;
|&lt;syntaxhighlight lang=&quot;python3&quot; inline&gt;yield&lt;/syntaxhighlight&gt;
| &amp;nbsp;
|}

&lt;nowiki&gt;*&lt;/nowiki&gt; Ne sont plus des mots-clés en Python 3 mais des fonctions du module &lt;code&gt;builtins&lt;/code&gt;.

Il faut ajouter les trois valeurs constantes True, False, None en python3 qui sont heureusement des mots clefs. Vous pouvez vous amuser en python2 à affecter True= False et Python ne dit rien ! C'est 1984 !

Autre classement :
{|class=&quot;wikitable&quot; style=&quot;margin:0.5em auto 0.5em auto; border-collapse:collapse;  padding:0.5em;&quot;
! Mot
! Définition
|-
| and || Opérateur ET booléen logique
|-
| as || 
|-
| assert || 
|-
| break || Sortie de boucle
|-
| class || Définition de classe d'objet ([[w:POO| Programmation Orientée Objet]])
|-
| continue || 
|-
| def || Définition de fonction
|-
| del || Suppression de
|-
| elif || Condition contraire
|-
| else || Contraire
|-
| except || Sauf (à utiliser après &quot;try&quot;)
|-
| exec || 
|-
| finally || 
|-
| for || Boucle
|-
| from || De
|-
| global || Définition (ou utilisation) dans une fonction d'une variable globale
|-
| if || Condition
|-
| import || Importation de module
|-
| in || Contient
|-
| is || Est
|-
| is not || N'est pas
|-
| lambda || Définition d'une fonction Lambda
|-
| not || Négation logique
|-
| or || Opérateur de choix OU booléen logique
|-
| pass || 
|-
| print || Afficher
|-
| raise || 
|-
| return || Stopper la fonction courante (renvoyer sa valeur)
|-
| sort || Classer par ordre alphabétique
|-
| try || Essayer (généralement suivi de &quot;except&quot; : sauf)
|-
| while || Boucle
|-
| yield || S'emploie uniquement dans une fonction, et renvoie son résultat régénéré
|}

== Les fonctions ==
{|class=&quot;wikitable&quot; style=&quot;margin:0.5em auto 0.5em auto; border-collapse:collapse; padding:0.5em;&quot;
! Commande
! Définition
|-
| help() || Affiche l'aide sur le paramètre
|-
| dir() || Affiche les méthodes du paramètre
|-
| print() || Affiche le texte en paramètre
|-
| input() || Enregistre la saisie de l'utilisateur
|-
| raw_input() || Équivalent à input() (sous Python 3, préférer input())
|-
| len() || Renvoie la taille du paramètre
|-
| range() || Affiche la liste des entiers de l'intervalle du paramètre
|-
| ord() || Renvoie l'ordinal associé au caractère en paramètre
|-
| locals() || Créer un dictionnaire (objet &quot;dict&quot;), dont le contenu est accessible avec &quot;[]&quot;
|-
| globals() || Comme locals() mais en incluant les variables globales
|-
| str() || Convertit une variable en caractères
|-
| int() || Convertit une variable en nombre entier
|-
! colspan=2| Fichiers
|-
| open() || Ouvrir un fichier
|-
| close() || Fermer un fichier
|-
| read() || Lire un fichier
|-
| readline() || Lire une ligne
|-
| readlines() || Lire les lignes séparées par des &quot;\n,&quot;
|-
| tell() || Donne la position d'un objet
|-
| seek() || Donne la position d'un objet
|-
| write() || Écrire dans un fichier
|}

== Les modules ==
Ils sont importés avant utilisation avec &quot;import&quot;.
{|class=&quot;wikitable&quot; style=&quot;clear:both; margin:0.5em auto 0.5em auto; border-collapse:collapse; padding:0.5em;&quot;
! Module
! Définition
|-
| anydbm || 
|- 
| array || Représentation de tableaux
|-
| atexit || Gestionnaire de fin de programme
|-
| bisect || Outils de tri de liste par la méthode de bissection
|-
| calendar || Ce module permet d'afficher un calendrier et d'accéder à des fonctions spécifiques
|-
| cmath || Module pour les nombres complexes
|-
| codecs || 
|-
| collections || 
|-
| commands || 
|-
| ConfigParser || 
|-
| copy || 
|-
| ctypes || 
|-
| datetime || 
|-
| decimal || 
|-
| dummy_thread || 
|-
| dummy_threading || 
|-
| exceptions || 
|-
| encodings.aliases || 
|-
| formatter || 
|-
| heapq || 
|-
| gettext || 
|-
| locale || 
|-
| linecache || 
|-
| marshall || 
|-
| math || Module de fonctions mathématiques (sqrt, sin, cos, tan, etc.)
|-
| mmap || 
|-
| operator || 
|-
| os ||  Module de fonction concernant le système d'exploitation (OS)
|-
| pickle || 
|-
| Queue || 
|-
| re || Regular expressions
|-
| shelve || 
|-
| shutil || 
|-
| signal || 
|-
| stat || 
|-
| string || 
|-
| StringIO || 
|-
| struct || 
|-
| subprocess || 
|-
| sys || 
|-
| textwrap || Formatage de texte
|-
| tempfile || 
|-
| thread || 
|-
| threading || 
|-
| time || 
|-
| timeit || 
|-
| traceback || 
|-
| unicodedata || 
|-
| xml.sax || 
|-
| warnings || 
|-
| whichdb || 
|-
| _winreg || 
|}</text>
      <sha1>18163v7z865nknrzrmej2cidjdbq4rp</sha1>
    </revision>
  </page>
  <page>
    <title>Technologie/Lignes et services de tramways/Prolongements et créations de lignes de tramways en Île-de-France/Le prolongement du T2</title>
    <ns>0</ns>
    <id>50410</id>
    <revision>
      <id>684282</id>
      <parentid>564837</parentid>
      <timestamp>2022-08-27T18:22:04Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4410" xml:space="preserve">{{Chapeau Lignes et services de tramways}}

{{Ébauche}}


&lt;br/&gt;
&lt;br/&gt;
&lt;br/&gt;
{| border=3 cellpadding=20 cellspacing=0 align=center
|-
| bgcolor=&quot;D473D4&quot; style=&quot;font-size:1.13em&quot; | '''Prolongements et créations de lignes de tramways en Île-de-France'''
|-
|}
&lt;br/&gt;
&lt;br/&gt;
&lt;br/&gt;

&lt;div style=&quot;text-align: center;&quot;&gt;[[File:Tramway-T.svg|250px]] [[File:Logo Paris tram ligne2.svg|250px]]&lt;/div&gt;       


'''Le prolongement du T2''' ira de la gare de La Défense jusqu'au pont de Bezons en passant dans Courbevoie, dans La Garenne-Colombes, dans Colombes et dans Bezons.


&lt;gallery widths=&quot;240px&quot; heights=&quot;240px&quot; perrow=&quot;4&quot;&gt;
Fichier:Travaux du T2 - Courbevoie - Bd de la Mission Marchande - station les Fauvelles - juin 2012.jpg|Le chantier de la stations des Fauvelles en juin 2012.
Fichier:Travaux du T2 - Bezons - station Pont de Bezons - juin 2012.jpg|Le chantier de la station pont de Bezons en juin 2012.
Fichier:T2 - Convoi exceptionnel 1.jpg|Transfert de matériel roulant par convoi exceptionnel de ''[[w:Porte de Versailles (métro de Paris)|Porte de Versailles]]'' à [[w:Colombes|Colombes]]
&lt;/gallery&gt;

=== Les stations du prolongement nord ===


Les noms des stations ont été choisis début février 2010 suite à une concertation des différents acteurs du projet et sont dorénavant définitifs


{| cellspacing=0 cellpadding=3 border=&quot;0&quot; style=&quot;border: 1px solid #999; background-color:#FFFFFF; text-align: center&quot;
|- bgcolor=&quot;#CCCCCC&quot;
! !! !! !! Station !! Lat/Long !! Zone !! Communes !! Correspondances 
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| '''[[w:Pont de Bezons|Pont de Bezons]]'''
| style=&quot;font-size:xx-small&quot; | {{coord|48.923294|2.217543|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Pont de Bezons}}
| 4
| [[w:Bezons|Bezons]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Parc Pierre Lagravère
| style=&quot;font-size:xx-small&quot; | {{coord|48.917654|2.224495|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Parc Pierre Lagravère}}
| 3
| [[w:Colombes|Colombes]]
| align=center |[[File:Tramway-T.svg|20px]] [[File:Logo Paris tram ligne1.svg|20px]] &lt;small&gt;(projet)&lt;/small&gt;
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Victor Basch
| style=&quot;font-size:xx-small&quot; | {{coord|48.914101|2.229366|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Victor Basch}}
| 3
| [[w:Colombes|Colombes]]
| align=center |[[File:Tramway-T.svg|20px]] [[File:Logo Paris tram ligne1.svg|20px]] &lt;small&gt;(à distance(projet))&lt;/small&gt;
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Jacqueline Auriol
| style=&quot;font-size:xx-small&quot; | {{coord|48.910645|2.234065|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Jacqueline Auriol}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Charlebourg
| style=&quot;font-size:xx-small&quot; | {{coord|48.908022|2.237863|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Charlebourg}}
| 3
| [[w:La Garenne-Colombes|La Garenne-Colombes]]
| align=left | [[File:Logo train transilien.svg|20px]] [[File:Logo Paris Transilien ligneL.svg|20px]] &lt;small&gt;(à distance)&lt;/small&gt;
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Les Fauvelles
| style=&quot;font-size:xx-small&quot; | {{coord|48.902451|2.239451|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Les Fauvelles}}
| 3
| [[w:La Garenne-Colombes|La Garenne-Colombes]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#bb4b9c&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Faubourg de l'Arche
| style=&quot;font-size:xx-small&quot; | {{coord|48.896639|2.240138|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Faubourg de l'Arche}}
| 3
| [[w:Courbevoie|Courbevoie]]
| align=left |
|}

'''un projet''' du [[w:SDRIF|SDRIF]] est envisager pour prolonger le T2 du pont de Bezons jusqu'à Sartrouville pour rejoindre la Tangentielle nord.

==== Ateliers sur le prolongement ====

Des ateliers seront construits à Colombes entre les stations Victor-Basch et Parc Pierre Lagravère, il aura 9 voies de garages.

=Avancement=

TERMINE</text>
      <sha1>fi7m0aflzfg4bh5q581k07bkq6snn4l</sha1>
    </revision>
  </page>
  <page>
    <title>Technologie/Lignes et services de tramways/Prolongements et créations de lignes de tramways en Île-de-France/Le prolongement du T1</title>
    <ns>0</ns>
    <id>50412</id>
    <revision>
      <id>684306</id>
      <parentid>644345</parentid>
      <timestamp>2022-08-27T18:44:44Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21135" xml:space="preserve">{{Chapeau Lignes et services de tramways}}


&lt;br/&gt;
&lt;br/&gt;
&lt;br/&gt;
{| border=3 cellpadding=20 cellspacing=0 align=center
|-
| bgcolor=&quot;007FFF&quot; style=&quot;font-size:1.13em;color:FFFFFF&quot; | '''Prolongements et créations de lignes de tramways en Île-de-France'''
|-
|}
&lt;br/&gt;
&lt;br/&gt;
&lt;br/&gt;
 

&lt;div style=&quot;text-align: center;&quot;&gt;[[File:Tramway-T.svg|250px]] [[File:Logo Paris tram ligne1.svg|250px]]&lt;/div&gt;


'''Le T1''' sera prolongé à l'ouest et à l'est. le prolongement vers l'ouest a deux phase, la première qui ira de la gare de Saint-Denis jusqu'à la gare d’Asnières-Gennevilliers les Courtilles en passant dans L'Île-Saint-Denis, dans Villeneuve La-Garenne et dans Gennevilliers il sera ouvert au public le 15 novembre 2012 la deuxième phase ira d’Asnières-Gennevilliers Les Courtilles jusqu'à Nanterre-La Boule en passant dans Asnières, dans Colombes et dans Nanterre, deux tracé sont possible, un qui passera à la gare du stade ou l'autre qui passera à la gare de Colombes, se prolongement sera mis en service vers 2020.      

= Première phase du prolongement ouest =

La première phase du prolongement permettra '''les correspondances''' avec la ligne C du RER à la gare de Gennevilliers et avec la ligne 13 du métro à la gare des Courtilles.  avec la ligne J du train de banlieue sur une variante à la gare de colombes et sur l'autre à la gare du stade les dernières correspondance sont sur [[Technologie/Lignes et services de tramways/Prolongements et créations de lignes de tramways en Île-de-France/Le prolongement du T2|le prolongement du T2]] aux arrêts Parc Pierre La Gravierre et à l’arrêt Gabriel-Péri où elle est à distance.

== Les travaux stations par stations d’Asnières-Gennevilliers Les Courtilles à l'Île-Saint-Denis. ==


&lt;gallery&gt;
Fichier:Travaux T1 Ouest - Station Anières Les courtilles - Juillet 2012.jpg|Asnières - Gennevilliers - Les Courtilles 
Fichier:Travaux T1 Ouest - Station le Luth - Juillet 2012.jpg|Le Luth 
Fichier:Travaux T1 Ouest - Station le Village - Juillet 2012 (3).jpg|Le Village 
Fichier:Travaux T1 Ouest - Station Thimbaud - Quai Asnieres - Juillet 2012 (2).jpg|Thimbaud 
Fichier:Travaux T1 Ouest - Gennevilliers RER et T1 - Juillet 2012 (2).jpg|Gare de Gennevilliers 
Fichier:Travaux T1 Ouest - station parc des chanteraines - Juillet 2012.jpg|Parc des Chanteraines 
Fichier:Travaux T1 Ouest - station chemin des reniers - Juillet 2012.jpg|Chemin des Reniers 
Fichier:Travaux T1 Ouest - station la Noue - Juillet 2012.jpg|La Noue 
Fichier:Travaux T1 Ouest - station mairie de Villeneuve la Garenne - Juillet 2012 (3).jpg|Mairie de Villeneuve-la-Garenne 
Fichier:Travaux T1 Ouest - station Ile Saint Denis - Juillet 2012.jpg|L'Île-Saint-Denis 
&lt;/gallery&gt;

{{message galerie}}


== Les stations de Gare de Saint-Denis RER à Asnières - Gennevilliers ==

Elles sont listées ci-dessous d'ouest en est :

{| cellspacing=0 cellpadding=3 border=&quot;0&quot; style=&quot;border: 1px solid #999; background-color:#FFFFFF; text-align: center&quot;
|- bgcolor=&quot;#CCCCCC&quot;
! !! !! !! Stations !! Lat/Long !! Zone !! Communes !! Correspondances
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Asnières - Gennevilliers - Les Courtilles (métro de Paris)|'''Asnières - Gennevilliers - Les Courtilles'''
| style=&quot;font-size:xx-small&quot; | {{coord|48.930254|2.28403|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Asnières - Gennevilliers - Les Courtilles}}
| 3
| [[w:Asnières-sur-Seine|Asnières-sur-Seine]], [[w:Gennevilliers|Gennevilliers]]
| align=center | [[File:Metro-M.svg|20px]] [[File:Paris m 13 jms.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Le Luth
| style=&quot;font-size:xx-small&quot; | {{coord|48.931523|2.288084|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Le Luth}}
| 3
| [[w:Gennevilliers|Gennevilliers]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Le Village
| style=&quot;font-size:xx-small&quot; | {{coord|48.933229|2.294538|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Le Village}}
| 3
| [[w:Gennevilliers|Gennevilliers]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Timbaud
| style=&quot;font-size:xx-small&quot; | {{coord|48.933098|2.301474|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Timbaud}}
| 3
| [[w:Gennevilliers|Gennevilliers]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Gare de Gennevilliers
| style=&quot;font-size:xx-small&quot; | {{coord|48.933346|2.307732|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Les Barbanniers/Gare de Gennevilliers}}
| 3
| [[w:Gennevilliers|Gennevilliers]]
| align=center | [[File:RER.svg|20px]] [[File:Paris rer C jms.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Parc des Chanteraines
| style=&quot;font-size:xx-small&quot; | {{coord|48.933835|2.313742|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Parc des Chanteraines}}
| 3
| [[w:Gennevilliers|Gennevilliers]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Chemin des Reniers
| style=&quot;font-size:xx-small&quot; | {{coord|48.934557|2.321419|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Chemin des Reniers}}
| 3
| [[w:Villeneuve-la-Garenne|Villeneuve-la-Garenne]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| La Noue
| style=&quot;font-size:xx-small&quot; | {{coord|48.935089|2.327904|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=La Noue}}
| 3
| [[w:Villeneuve-la-Garenne|Villeneuve-la-Garenne]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Mairie de Villeneuve-la-Garenne
| style=&quot;font-size:xx-small&quot; | {{coord|48.935523|2.333274|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Mairie de Villeneuve-la-Garenne}}
| 3
| [[w:Villeneuve-la-Garenne|Villeneuve-la-Garenne]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| L'Île-Saint-Denis
| style=&quot;font-size:xx-small&quot; | {{coord|48.935738|2.339052|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=L'Île-Saint-Denis}}
| 3
| [[w:L'Île-Saint-Denis|L'Île-Saint-Denis]]
| align=left |
|} 

(les stations en gras servent de terminus)

=== Avancement ===

Ce prolongement est maintenant terminé.

= Deuxième phase du prolongement ouest =

La deuxième phase du prolongement permettra les '''correspondances ''' avec la ligne J du train de banlieue sur une variante à la gare de colombes et sur l'autre à la gare du stade les dernières correspondance sont sur [[Technologie/Lignes et services de tramways/Prolongements et créations de lignes de tramways en Île-de-France/Le prolongement du T2|le prolongement du T2]] aux arrêts Parc Pierre La Gravierre et à l’arrêt Gabriel-Péri où elle est à distance.
 
=== Les stations de colombes à Asnières. === 

Elles sont listées ci-dessous d'ouest en est, la variante noire est celle qui n'a pas été retenue pour le prolongement car il y avait trop de maison à abattre, faute de la largeur de la rue:


{| class=&quot;alternance&quot; cellspacing=0 cellpadding=3 border=&quot;0&quot; style=&quot;border: 1px solid #999; background-color:#FFFFFF; text-align: center&quot;
|- bgcolor=&quot;#CCCCCC&quot;
! bgcolor=&quot;#CCCCCC&quot; | !! bgcolor=&quot;#CCCCCC&quot; | !! bgcolor=&quot;#CCCCCC&quot; | !! bgcolor=&quot;#CCCCCC&quot; | !! bgcolor=&quot;#CCCCCC&quot; | !! scope=&quot;col&quot; bgcolor=&quot;#CCCCCC&quot; | Stations !! scope=&quot;col&quot; bgcolor=&quot;#CCCCCC&quot; | Lat/Long !! scope=&quot;col&quot; bgcolor=&quot;#CCCCCC&quot; | Zone !! scope=&quot;col&quot; bgcolor=&quot;#CCCCCC&quot; | Communes !! scope=&quot;col&quot; bgcolor=&quot;#CCCCCC&quot; | Correspondances
|-
| bgcolor=&quot;#ffffff&quot; colspan=2 |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; colspan=2 |&amp;nbsp;
| '''Gabriel Peri'''
| style=&quot;font-size:xx-small&quot; | {{coord|48.913538|2.226767|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Gabriel Peri}}
| 3
| [[w:Colombes|Colombes]]
| align=center |[[File:Tramway-T.svg|20px]] [[File:Logo Paris tram ligne2.svg|20px]] &lt;small&gt;(à distance)&lt;/small&gt;
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; colspan=2 |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#fofofo&quot; colspan=2 |&amp;nbsp;
| Parc Pierre Lagravère
| style=&quot;font-size:xx-small&quot; | {{coord|48.917654|2.224495|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Parc Pierre Lagravère}}
| 3
| [[w:Colombes|Colombes]]
| align=center |  [[File:Tramway-T.svg|20px]] [[File:Logo Paris tram ligne2.svg|20px]]
|-
| bgcolor=&quot;#ffffff&quot; colspan=2 |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; colspan=2 |&amp;nbsp;
| Les Greves
| style=&quot;font-size:xx-small&quot; | {{coord|48.920021|2.227772|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Les Greves}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; colspan=2 |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#fofofo&quot; colspan=2 |&amp;nbsp;
| Charles Péguy
| style=&quot;font-size:xx-small&quot; | {{coord|48.922182|2.232842|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Charles Péguy}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#000000&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#006cb8&quot; |&amp;nbsp; || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Île Marante
| style=&quot;font-size:xx-small&quot; | {{coord|48.924632|2.239021|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Île Marante}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#000000&quot; |&amp;nbsp; || bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#fofofo&quot;|&amp;nbsp;
| Stade Yves du Manoir
| style=&quot;font-size:xx-small&quot; | {{coord|48.928209|2.24799|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Stade Yves du Manoir}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#000000&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |&amp;nbsp; || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Paul Bert
| style=&quot;font-size:xx-small&quot; | {{coord|48.927127|2.247079|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Paul Bert}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#000000&quot; |&amp;nbsp; || bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#fofofo&quot;|&amp;nbsp;
| Valmy Nord
| style=&quot;font-size:xx-small&quot; | {{coord|48.933679|2.255563|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Valmy Nord}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#000000&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |&amp;nbsp; || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Général Leclerc
| style=&quot;font-size:xx-small&quot; | {{coord|48.923211|2.252432|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Général Leclerc}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#000000&quot; |&amp;nbsp; || bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#fofofo&quot;|&amp;nbsp;
| Gare du Stade
| style=&quot;font-size:xx-small&quot; | {{coord|48.934673|2.26256|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Gare du Stade}}
| 3
| [[w:Colombes|Colombes]]
| align=center |   [[File:Logo train transilien.svg|20px]] [[File:Logo Paris Transilien ligneJ.svg|20px]]
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#000000&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |&amp;nbsp; || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Gare de Colombes
| style=&quot;font-size:xx-small&quot; | {{coord|48.923454|2.259234|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Gare de Colombes}}
| 3
| [[w:Colombes|Colombes]]
| align=center | [[File:Logo train transilien.svg|20px]] [[File:Logo Paris Transilien ligneJ.svg|20px]]
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#000000&quot; |&amp;nbsp; || bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#fofofo&quot;|&amp;nbsp;
| Fossés-Jean
| style=&quot;font-size:xx-small&quot; | {{coord|48.93198|2.266422|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Fossés-Jean}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#000000&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |&amp;nbsp; || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Rue des Écoles
| style=&quot;font-size:xx-small&quot; | {{coord|48.92484|2.266637|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Rue des Écoles}}
| 3
| [[w:Colombes|Colombes]]
| align=left |
|-bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#fofofo&quot; |&amp;nbsp; || bgcolor=&quot;#000000&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#006cb8&quot; |&amp;nbsp; || bgcolor=&quot;#fofofo&quot; |&amp;nbsp;
| Quatre Routes
| style=&quot;font-size:xx-small&quot; | {{coord|48.926856|2.273348|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Quatre Routes}}
| 3
| [[w:Colombes|Colombes]], [[w:Bois-Colombes|Bois-Colombes]], [[w:Asnières-sur-Seine|Asnières-sur-Seine]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot; colspan=2 |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; colspan=2 |&amp;nbsp;
| Freycinet
| style=&quot;font-size:xx-small&quot; | {{coord|48.928146|2.277254|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Freycinet}}
| 3
| [[w:Asnières-sur-Seine|Asnières-sur-Seine]]
| align=left |
|}

== Ateliers ==

Il est prévu que le tramway partage les ateliers de la marine avec le T2.

= Le prolongement est =

'''Le prolongement du T1 vers l'est''' ira de la gare de Noisy le Sec jusqu'à celle de Val de Fontenay, pour l'instant il n'est pas possible de commencer les travaux car le nouveau maire de Noisy-le-Sec ne veut pas de tramway dans sa ville, donc il faut attendre qu'un autre maire soit élu.
Plusieurs tracés sont possibles pour traverser Noisy le Sec :

* Le tracé '''Jaurès''' qui fait passer le tramway dans le centre de la ville en site propre vers Asnières et en site partagé avec les voitures vers Fontenay.

* Le tracé '''dissocié Jaurès-Michelet''' qui fait passer le tram dans la rue Jean-Jaurès vers Fontenay et sa rue parallèle, le boulevard Michelet vers Asnières.

* Le tracé '''ouest''' qui contourne le centre de la ville en passant par la zone d'activité à l'ouest de la ville et par la base de loisirs de &quot;la corniche des forts&quot;.        

Le prolongement permettra '''les correspondances''' avec la ligne 11 du métro sur son prolongement vers Rosny-Bois-Perrier, à place Carnot, la ligne 9 sur son prolongement à Théophile Sueur (la station du métro s'appellera Montreuil murs à pêches) puis la ligne 1 du métro (prolongement à l'étude) et la ligne A et E du RER à Val de Fontenay.Il passera dans les villes de Noisy-le-Sec, Romainville, Montreuil, Rosny-sous-Bois et Fontenay-sous-Bois.   

Un nouveau matériel roulant devrait être commandé pour ce prolongement : des ''Citadis compact'' non jumelables.

=== Les stations du prolongement est ===

Entre Noisy-le-Sec et Montreuil, les stations indiquées sont celles du tracé « Jaurès ».

''Les noms des stations ne sont pas définitifs. Les coordonnées et les zones sont approximatives.''

{| cellspacing=0 cellpadding=3 border=&quot;0&quot; style=&quot;border: 1px solid #999; background-color:#FFFFFF; text-align: center&quot;
|- bgcolor=&quot;#CCCCCC&quot;
! !! !! !! Stations !! Lat/Long !! Zone !! Communes !! Correspondances
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Carnot-Jaurès
&lt;small&gt;ou Saint Jean&lt;/small&gt;
| style=&quot;font-size:xx-small&quot; | {{coord|48.893126|2.456602|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Saint Jean}}
| 3
| [[w:Noisy-le-Sec|Noisy-le-Sec]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Place Jeanne-d'Arc
| style=&quot;font-size:xx-small&quot; | {{coord|48.889984|2.452751|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Place Jeanne-d'Arc}}
| 3
| [[w:Noisy-le-Sec|Noisy-le-Sec]]
| align=left |
|- 
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Rues Louise / Hélène
| style=&quot;font-size:xx-small&quot; | {{coord|48.888354|2.450579|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Rues Louise / Hélène}}
| 3
| [[w:Noisy-le-Sec|Noisy-le-Sec]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Carrefour de la Vierge
| style=&quot;font-size:xx-small&quot; | {{coord|48.886802|2.448475|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Carrefour de la Vierge}}
| 3
| [[w:Noisy-le-Sec|Noisy-le-Sec]], [[w:Romainville|Romainville]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Place Carnot
| style=&quot;font-size:xx-small&quot; | {{coord|48.883969|2.440777|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Place Carnot}}
| 3
| [[w:Romainville|Romainville]]
| align=left | [[File:Metro-M.svg|20px]] [[File:Paris m 11 jms.svg|20px]] (future)
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Collège Gustave Courbet
| style=&quot;font-size:xx-small&quot; | {{coord|48.878456|2.44134|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Collège Courbet}}
| 3
| [[w:Romainville|Romainville]]
| align=left |
|- 
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Libre Pensée
| style=&quot;font-size:xx-small&quot; | {{coord|48.875926|2.442885|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Libre Pensée}}
| 3
| [[w:Romainville|Romainville]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Route de Romainville
| style=&quot;font-size:xx-small&quot; | {{coord|48.872306|2.447622|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Route de Romainville}}
| 3
| [[w:Montreuil|Montreuil]]
| align=left |
|- 
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Aristide Briand
| style=&quot;font-size:xx-small&quot; | {{coord|48.870521|2.451656|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Aristide Briand}}
| 3
| [[w:Montreuil|Montreuil]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Rue de Rosny
| style=&quot;font-size:xx-small&quot; | {{coord|48.867041|2.457702|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Rue de Rosny}}
| 3
| [[w:Montreuil|Montreuil]]
| align=left |
|- 
| bgcolor=&quot;#ffffff&quot; |&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot; |&amp;nbsp;
| Théophile Sueur&lt;br /&gt;&lt;small&gt;''Mur à Pêches''&lt;/small&gt;
| style=&quot;font-size:xx-small&quot; | {{coord|48.863461|2.463586|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Théophile Sueur}}
| 3
| [[w:Montreuil|Montreuil]]
| align=center | [[File:Metro-M.svg|20px]] [[File:Paris m 9 jms.svg|20px]] (projet)
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Côte du Nord
| style=&quot;font-size:xx-small&quot; | {{coord|48.862204|2.47381|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Côte du Nord}}
| 3
| [[w:Montreuil|Montreuil]]
| align=left |
|- 
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Victor Hugo
| style=&quot;font-size:xx-small&quot; | {{coord|48.861682|2.482318|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Victor Hugo}}
| 3
| [[w:Montreuil|Montreuil]], [[w:Rosny-sous-Bois|Rosny-sous-Bois]], [[w:Fontenay-sous-Bois|Fontenay-sous-Bois]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Faidherbe
| style=&quot;font-size:xx-small&quot; | {{coord|48.860729|2.488198|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Faidherbe}}
| 3
| [[w:Rosny-sous-Bois|Rosny-sous-Bois]], [[w:Fontenay-sous-Bois|Fontenay-sous-Bois]]
| align=left |
|- 
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#006cb8&quot; |{{blanc|o}} || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| '''[[w:Gare du Val de Fontenay|Val de Fontenay]]'''
| style=&quot;font-size:xx-small&quot; | {{coord|48.855007|2.490183|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Val de Fontenay}}
| 3
| [[w:Fontenay-sous-Bois|Fontenay-sous-Bois]]
| align=center | [[File:RER.svg|20px]] [[File:Paris RER A icon.svg|20px]] [[File:Paris rer E jms.svg|20px]] 
[[File:Logo Ligne 1.svg|40px]]  (projet)
|}

==== Ateliers sur le prolongement est ====

De nouveaux ateliers seront construits à Montreuil entre la station rue de Rosny et Téophile Sueur, il y aura 11 voies de garage.</text>
      <sha1>jdz901vemqiew6cuyn7gd28enwqp1qp</sha1>
    </revision>
  </page>
  <page>
    <title>Technologie/Lignes et services de tramways/Prolongements et créations de lignes de tramways en Île-de-France/Le prolongement du T3</title>
    <ns>0</ns>
    <id>50465</id>
    <revision>
      <id>684281</id>
      <parentid>564838</parentid>
      <timestamp>2022-08-27T18:21:36Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7444" xml:space="preserve">{{Chapeau Lignes et services de tramways}}


&lt;br/&gt;
&lt;br/&gt;
&lt;br/&gt;
{| border=3 cellpadding=20 cellspacing=0 align=center
|-
| bgcolor=&quot;FEA347&quot; style=&quot;font-size:1.13em;&quot; | '''Prolongements et créations de lignes de tramways en Île-de-France'''
|-
|}
&lt;br/&gt;
&lt;br/&gt;
&lt;br/&gt;


&lt;div style=&quot;text-align: center;&quot;&gt;[[File:Tramway-T.svg|250px]] [[File:Logo Paris tram ligne3a.svg|250px]]&lt;/div&gt;

Le prolongement du T3 ou T3a ira de la Porte d'Ivry, le terminus actuel, jusqu'à la Porte de Vincennes où il sera repris par la deuxième ligne le T3b pour aller jusqu'à la Porte de la Chapelle (détails:[[Technologie/Lignes et services de tramways/Prolongements et créations de lignes de tramways en Île-de-France/La création du T3b|la création du T3b]]). Le prolongement passera dans le 13{{e}} arrondissement le 12&lt;sup&gt;e&lt;/sup&gt; et le 20è, il sera mis en service fin 2012.

L'avancement des travaux en Juillet 2012 du nord vers le sud:

&lt;gallery  perrow=&quot;6&quot;&gt;
Fichier:Travaux extension T3 - Porte de Vincennes - Juillet 2012 (5).jpg|Le nouvel accès au métro à la porte de Vincennes.  
Fichier:Travaux extension T3 - Porte de Vincennes - Juillet 2012 (6).jpg|La station Porte de Vincennes avec le pont de la grande ceinture. 
Fichier:Travaux extension T3 - Porte de Vincennes - Juillet 2012.jpg|Les voies qui partent vers la droite vont vers le quai de la stations porte de Vincennes et celles qui continue sont la connexion avec le T3b. 
Fichier:Travaux extension T3 - Station Alexandra david-Neel - Juillet 2012.jpg|La station Alexandra David-Néel.  
Fichier:Travaux extension T3 - Station porte Doree - Juillet 2012 (6).jpg|La station Porte Dorée.  
Fichier:Travaux extension T3 - Entre porte de Charenton et Baron leroy - Juillet 2012 (2).jpg|La voie entre les stations Porte de Charenton et Baron Leroy avec le pont sur la seine au fond avec le sol en bois.
Fichier:Travaux extension T3 - Entre Baron leroy et Avenue de France - Juillet 2012 (3).jpg|La voie entre les stations Baron Leroy et Avenue de France.  
Fichier:Travaux extension T3 - Entre Baron leroy et Avenue de France - Juillet 2012.jpg|Toujours entre Baron Leroy et Avenue de France mais à un autre endroit.  
Fichier:Travaux extension T3 - Station avenue de France - Juillet 2012 (2).jpg|La station Avenue de France.  
Fichier:Travaux extension T3 - Entre Avenue de France et Maryse Bastie - Juillet 2012.jpg|La voie entre les stations Avenue de France et Maryse Bastié avec dans le creux la station Maryse Bastié.  
Fichier:Travaux extension T3 - Station maryse bastie - Juillet 2012.jpg|La station Maryse Bastié.  
Fichier:Travaux extension T3 - Entre maryse bastie et Porte d'Ivry - Juillet 2012 (3).jpg|Le perchage des caténaire près de la Porte d'Ivry.  
Fichier:Travaux extension T3 - Entre maryse bastie et Porte d'Ivry - Juillet 2012.jpg|La limite d'exploitation de la ligne à la Porte d'Ivry. 
&lt;/gallery&gt;


Le prolongement permettra les correspondances avec la ligne 8 du métro à la Porte de Charenton et à la Porte Dorée et avec la ligne 1 du métro et le T3b à la Porte de Vincennes.

==== De la porte d'Ivry à la porte de Vincennes ====

{| cellspacing=0 cellpadding=3 border=&quot;0&quot; style=&quot;border: 1px solid #999; background-color:#FFFFFF; text-align: center&quot;
|- bgcolor=&quot;#CCCCCC&quot;
!&amp;nbsp;!!&amp;nbsp;!!&amp;nbsp;!! Station !! Lat/Long !! Zone !! Communes !! Correspondances
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Maryse Bastié
&lt;small&gt;ou Porte de Vitry&lt;/small&gt;
| style=&quot;font-size:xx-small&quot; | {{coord|48.824071|2.376935|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Maryse Bastié}}
| 1
| [[w:13e arrondissement de Paris|13{{e}}]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Avenue de France
&lt;small&gt;ou Porte de France&lt;/small&gt;
&lt;small&gt;Bibliothèque François Mitterrand&lt;/small&gt;
| style=&quot;font-size:xx-small&quot; | {{coord|48.825476|2.381119|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Avenue de France}}
| 1
| [[w:13e arrondissement de Paris|13{{e}}]]
| align=center |[[File:RER.svg|20px]][[File:Paris RER C icon.svg|20px]] 
[[File:Metro-M.svg|20px]][[File:Paris m 14 jms.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Baron Le Roy
| style=&quot;font-size:xx-small&quot; | {{coord|48.829368|2.390368|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Baron Le Roy}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Porte de Charenton (métro de Paris)|Porte de Charenton]]
| style=&quot;font-size:xx-small&quot; | {{coord|48.831741|2.397801|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Porte de Charenton}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]]
| align=center | [[File:Logo Ligne 8.svg|40px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Porte Dorée (métro de Paris)|Porte Dorée]]
| style=&quot;font-size:xx-small&quot; | {{coord|48.835505|2.406741|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Porte Dorée}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]]
| align=center | [[File:Logo Ligne 8.svg|40px]] 
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Montempoivre
&lt;small&gt;ou Porte de Montempoivre&lt;/small&gt;
| style=&quot;font-size:xx-small&quot; | {{coord|48.840689|2.409159|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Montempoivre}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| Alexandra David-Néel
&lt;small&gt;ou Porte de Saint Mandé&lt;/small&gt;
| style=&quot;font-size:xx-small&quot; | {{coord|48.844265|2.41028|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Alexandra David-Néel}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#f68c59&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| '''[[w:Porte de Vincennes (métro de Paris)|Porte de Vincennes]]'''
| style=&quot;font-size:xx-small&quot; | {{coord|48.847012|2.410296|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Porte de Vincennes}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]], [[w:20e arrondissement de Paris|20{{e}}]]
| align=center | [[File:Metro-M.svg|20px]][[File:Paris m 1 jms.svg|20px]] 
[[File:Tramway-T.svg|20px]][[File:Logo Paris tram ligne3b.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#008b5a&quot; |&lt;span style=&quot;color:white&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| liaison vers le [[File:Tramway-T.svg|20px]][[File:Logo Paris tram ligne3b.svg|20px]]
| style=&quot;font-size:xx-small&quot; | {{coord|48.847234|2.410334|region:FR_type:landmark_scale:1000|format=dms|display=inline|name=Porte de Vincennes}}
| 1
| [[w:12e arrondissement de Paris|12{{e}}]], [[w:20e arrondissement de Paris|20{{e}}]]
| align=center |
|}
(''Les noms des stations ne sont pas définitifs. Les coordonnées et les zones sont approximatives.'')

== Avancement ==

Ce projet est maintenant terminé.</text>
      <sha1>azkiteoy3hzk4l7yutv9p5mzpuu4iri</sha1>
    </revision>
  </page>
  <page>
    <title>Cynologie/Ankylostome</title>
    <ns>0</ns>
    <id>53181</id>
    <revision>
      <id>684299</id>
      <parentid>397221</parentid>
      <timestamp>2022-08-27T18:34:00Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24996" xml:space="preserve">{{Cynologie}}
Les '''ankylostomoses''' sont des parasitoses intestinales provoquées par deux nématodes (petits vers ronds très voisins) qui entraînent par leur présence dans le duodéno-jéjunum de l'animal, une seule et même maladie à savoir l'ankylostomose :
* ''Ancylostoma duodenale''
* ''Necator americanus''

==Parasite==
L’'''ankylostome''' est un ver parasite (de la classe des nématodes) qui vit dans le duodénum de son hôte, qui peut être un mammifère comme un chien, un chat, ou un [[w:homo sapiens|humain]]. Les espèces de ''[[w:Ankylostoma braziliense|A. braziliense]] '' et '' [[w:Ankylostoma tubaeforme|A. tubaeforme]] '' infectent les chats, alors que ''[[w:Ankylostoma caninum|A. caninum]] '' infecte les chiens. ''Uncinaria stenocephala'' infecte les chiens et les chats. 

Les ankylostomes sont beaucoup plus petits que le plus grand des vers ronds [[w:ascaris (parasite)|ascaris lumbricoïdes]], et les complications de la migration dans les tissus et de l'obstruction mécanique si fréquemment observées avec l'infestation d'ascaris lumbricoïdes sont plus rares dans l'infestation par l'ankylostome. Le risque le plus caractéristique de l'infection par l'ankylostome est l’anémie, consécutive à la perte de fer (et de protéines) dans l'intestin. Les vers sucent le sang avec voracité et endommagent la muqueuse. Cependant, la perte de sang dans les selles est une perte occulte (qui n’est pas visiblement apparente).

L’ankylostome est une des causes prédominantes de morbidité chez les animaux dans les pays en voie de développement dans les régions tropicales et subtropicales. Chez les chiots les plus fragiles l’ankylostome est responsable d’un retard cognitif et d’un retard de croissance. Il entraîne un retard de croissance intra-utérine, un risque de prématurité, un bas poids de naissance chez les fœtus ou chiots nés de femelles infectées. L'infection par l'ankylostome est rarement mortelle, mais l'anémie peut être significative chez l'animal fortement infesté. Les larves peuvent survivre six mois dans le sol humide et les eaux boueuses à température tempérée.

[[Image:Hookworms.JPG|thumb|250px|right|Ankylostomes fixés à la muqueuse intestinale]]

==Pathologie==
Du point de vue clinique, on distingue les manifestations aiguës dues à la pénétration et la migration des larves :
* dermatite d'invasion : érythème prurigineux de quelques jours aux extrémités des membres.
* lésions cutanées (urticaires, plaques prurigineuses, pustules) plus ou moins surinfectées, dues à l'hypersensibilité créée par les infestations multiples.
* manifestations d'irritation des voies respiratoires supérieures (toux, dysphonie, pharyngite, sialorrhée...).
* duodénite : douleurs épigastriques et diarrhées des manifestations chroniques représentées essentiellement par une anémie.

La plupart des animaux infectés par l'ankylostome sont asymptomatiques (sans symptômes). Généralement, des charges très élevées en parasite associées à une nutrition carencée (apports insuffisants en protéines et en fer) provoquent par la suite une anémie. La maladie a été attribuée aux nématodes (''Ankylostoma duodenalis'') vers d'un tiers de pouce à un demi pouce de long dans l'intestin. 

Les symptômes peuvent être liés à l'inflammation de l'intestin irrité par les lésions provoquées par les ankylostomes qui se nourrissent, tels que nausée, douleur abdominale et diarrhée intermittente, ainsi que l'anémie progressive dans la maladie prolongée : appétit capricieux, [[w:Pica (maladie)|pica]], constipation persistante entrecoupée de diarrhée, palpitations, pâleur de la peau et des muqueuses, fatigue et asthénie, essoufflement et dans certains cas évolution vers une issue mortelle, dysenterie, hémorragies et œdème. Les analyses de sang dans l'infection montrent souvent très tôt une augmentation du nombre de polynucléaires éosinophiles dans le sang, un type de globules blancs qui est préférentiellement stimulé par la présence de vers dans les tissus (un grand nombre d'éosinophiles sont également présents dans la réaction inflammatoire locale). Une baisse du taux d'hémoglobine dans le sang apparaîtra dans les cas d'infection prolongée en relation avec l'anémie.

Contrairement à la plupart des helminthiases intestinales où les charges parasitaires les plus élevées se retrouvent chez les chiots, la prévalence et l'intensité de l'ankylostome peuvent être plus élevées parmi les adultes. Cependant, dans la plupart des secteurs endémiques, les femelles sont les plus sévèrement affectées par l'anémie, principalement parce qu'elles ont des besoins physiologiques beaucoup plus élevés en fer (menstruations, grossesses répétées).

Une conséquence intéressante de ce fait dans le cas de l'infection par ''Ankylostoma duodenale'' est la transmission de l'infection par le lait maternel : les larves invasives par voie transcutanée de ces espèces ne passent pas toutes immédiatement par les poumons et vers l'intestin, mais se répandent dans tout l’organisme par transport sanguin, pour devenir des larves dormantes à l’intérieur des fibres musculaires. Chez la femelle enceinte, après l'accouchement quelques-unes ou la totalité de ces larves sont stimulées pour être remises en circulation dans le sang (vraisemblablement par les changements hormonaux soudains), puis pour passer dans les glandes mammaires, de sorte que les chiots nouveau-né peut recevoir une dose élevée de larves contagieuses par le lait maternel. Ceci explique des cas autrement inexplicables d'infections par l'ankylostome très lourdes, voire mortelles, chez des chiots âgés de quelques mois. 

==Cycle parasitaire==
[[Image:Hookworm LifeCycle(French version).GIF|thumb|right|600px|'''Cycle parasitaire de l'ankylostome''']]
L’ankylostome prospère dans la terre chaude où la température dépasse {{Unité|18|°C}}. Il vit principalement dans le sable ou les sols de terre grasse et ne peut pas vivre dans l’argile ou le fumier. Le niveau moyen des précipitations doit dépasser {{unité|1000|mm}} par an. C’est seulement si ces conditions sont réunies que les œufs peuvent éclore.
Les larves infestantes de ''Necator américanus'' peuvent survivre à des températures élevées, tandis que celles d’''Ankylostoma duodenale'' sont mieux adaptées à des climats plus frais. Généralement, elles ne survivent que durant quelques semaines, tout au plus dans des conditions normales, et meurent presque immédiatement au contact de la lumière directe du soleil ou sous l’effet de la dessiccation. Une fois dans l'intestin de l’hôte, ''Necator américanus'' tend à provoquer une infection prolongée. D'une part, les adultes d’''Ankylostoma duodenale'' ont une durée de vie plus courte, puisqu’ils survivent en moyenne seulement pendant six mois environ. Cependant, l'infection peut être prolongée parce que des larves dormantes peuvent « être recrutées » séquentiellement à partir du tissu « de stockage » pendant de nombreuses années, pour remplacer les vers adultes morts. Ceci peut provoquer des fluctuations saisonnières dans la prévalence et l'intensité de l'infection (indépendamment des variations saisonnières de transmission habituelles). 

[[Image:CPS141privydigging.jpg|thumb|Service public civil : des ouvriers construisent et installent {{formatnum:2065}} sanitaires pour l'éradication de l'ankylostome au Mississippi et en Floride de 1943 à 1947.]] 

Puisqu’il faut environ 5 à 7 semaines pour que les vers adultes deviennent matures, pour qu’ils s’accouplent et produisent des œufs, dans les premiers stades d’une infection massive, des symptômes aigus pourraient se manifester sans qu’aucun œuf ne soit détecté dans les selles de l'animal. Ceci peut rendre le diagnostic très difficile.

==Diagnostic==
Les larves infestantes se développent et survivent dans un environnement souillé et humide, un sol particulièrement sableux et gras. Ils ne peuvent pas survivre dans l’argile ou le fumier. Les axes principaux de la prévention sont ceux édictés par les règles sanitaires 

[[Image:Canine hookworm egg 1.JPG|thumb|left|Œufs d'ankylostomes]]

Il n'y a aucun symptôme ou signe spécifique de l'infection par l'ankylostome. Comme mentionné ci-dessus, ils résultent d'une combinaison de signes d'inflammation intestinale et d'anémie progressive par carence en fer. La pénétration de la larve à travers la peau peut provoquer des démangeaisons locales intenses, habituellement sur les pattes, qui peut être suivie de lésions qui ressemblent aux piqûres d'insecte, avec des boursouflures, et durent une semaine ou plus. La toux, la douleur thoracique, la dyspnée laryngée, et fièvre seront parfois présentes chez les animaux qui ont été infestées par un très grand nombre de larves. Les douleurs épigastriques, indigestion, nausées vomissements, constipation, et diarrhée peuvent survenir à l’étape initiale aussi bien que plus tardivement, bien que les symptômes gastro-intestinaux tendent à s'atténuer avec le temps. Les signes de l'infection grave évoluée sont ceux de l'anémie et de la déficience en protéines, y compris l'amaigrissement, la défaillance cardiaque et la distension abdominale avec de l'ascite.

Le diagnostic dépend de la découverte d’œufs d’ankylostomes caractéristiques à l'examen au microscope des selles, bien que ce ne soit pas possible au début de l'infection. Comme les œufs d’''Ankylostome'' et de ''Necator'' (et de la plupart des autres espèces d'ankylostomes) sont impossibles à distinguer les uns des autres, pour identifier le genre, ils doivent être cultivés en laboratoire pour permettre à des larves d’éclore. Si l'échantillon de selles est laissé pendant un jour ou plus dans des conditions tropicales, les larves peuvent avoir éclos, aussi les œufs peuvent ne plus être détectables. En ce cas, il est essentiel de distinguer les ankylostomes des larves de ''Strongyloides'', car l'infection avec ses dernières a des conséquences plus sérieuses et exige une gestion différente. Les larves des deux espèces d'ankylostomes peuvent également être distinguées au microscope, bien que ceci ne soit pas fait d’habitude, mais seulement pour des recherches. Les vers d'adulte sont rarement décelables (excepté par le biais de l'endoscopie, de la chirurgie ou l'autopsie), mais leur découverte permettrait l'identification définitive des espèces.

==Traitement==
L'ankylostome peut être traité localement par cryothérapie quand il est toujours dans la peau. L’Albendazole est efficace à l'étape intestinale et pendant l'étape où le parasite migre toujours sous la peau. En cas d'anémie, la supplémentation en fer peut atténuer les symptômes de l’anémie ferriprive. Cependant, lorsque le taux de globules rouges revient à la normale, le manque d'autres substances comme l’acide folique ou la vitamine B12 peut apparaître qui peuvent également nécessiter une supplémentation.

==Quick Facts==

{| border=&quot;2&quot; cellpadding=&quot;5&quot; cellspacing=&quot;0&quot; class=&quot;wikitable centre&quot;
|-
! '''Genus and Species'''
! '''Necator americanus'''
! '''Ancylostoma duodenale'''
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Common Name''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| New world hookworm, American murderer
|width=&quot;400pt&quot; align=&quot;center&quot;| Old world hookworm
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Etiologic Agent of:''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Necatoriasis, Uncinariasis
|width=&quot;400pt&quot; align=&quot;center&quot;| Ancylostomiasis, Wakana disease
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Infective stage''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Filariform larva
|width=&quot;400pt&quot; align=&quot;center&quot;| Filariform larva
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Definitive Host''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Man
|width=&quot;400pt&quot; align=&quot;center&quot;| Man
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Portal of Entry''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Usually via skin penetration rather than ingestion
|width=&quot;400pt&quot; align=&quot;center&quot;| Usually via ingestion rather than skin penetration
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Mode of Transmission''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Skin &gt; Mouth
|width=&quot;400pt&quot; align=&quot;center&quot;| Mouth &gt; Skin
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Habitat'''
|width=&quot;400pt&quot; align=&quot;center&quot;| Small Intestine
|width=&quot;400pt&quot; align=&quot;center&quot;| Small Intestine
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Pathogenic Stage''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Adult Larva
|width=&quot;400pt&quot; align=&quot;center&quot;| Adult Larva
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Mode of Attachment''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Oral attachment to mucosa by sucking
|width=&quot;400pt&quot; align=&quot;center&quot;| Same
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Mode of Nutrition''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Sucking and Ingesting of blood
|width=&quot;400pt&quot; align=&quot;center&quot;| Same
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Pathogenesis''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Larva – ground / dew itch, creeping eruption Adult – IDA Microcytic, Hypochromic Anemia
|width=&quot;400pt&quot; align=&quot;center&quot;| Same
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Laboratory diagnosis''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Concentration methods and Direct Fecal Smear
|width=&quot;400pt&quot; align=&quot;center&quot;| Same
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Treatment''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Albendazole, Mébendazole, or Pyrantel Pamoate
|width=&quot;400pt&quot; align=&quot;center&quot;| Same
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Diagnostic Feature - Adult''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| Semi-lunar cutting plate; Bipartite dorsal ray
|width=&quot;400pt&quot; align=&quot;center&quot;| Male – Tripartite dorsal ray
|-
|width=&quot;200pt&quot; align=&quot;center&quot;| '''Diagnostic Feature - Egg''' 
|width=&quot;400pt&quot; align=&quot;center&quot;| In Morula
|width=&quot;400pt&quot; align=&quot;center&quot;| In Morula
|-
|}

{{Taxobox début | animal | ''Ancylostoma duodenale'' | Ancylostoma duodenale boca.jpg |''Ancylostoma duodenale''  }}
{{Taxobox | embranchement | Nematoda    }}
{{Taxobox | classe | Secernentea }}
{{Taxobox | ordre | Strongylida  }}
{{Taxobox | famille | Ancylostomidae  }}
{{Taxobox | genre | Ancylostoma}}
{{Taxobox taxon | animal | espèce | Ancylostoma duodenale  |  ([[w:Angelo Dubini|Dubini]], 1843) }}
{{Taxobox fin}}

'''''Ankylostoma duodenale''''' est une [[w:espèce (biologie)|espèce]] de nématodes (les nématodes sont un [[w:embranchement (biologie)|embranchement]] de vers non segmentés, recouverts d'une épaisse cuticule et menant une vie libre ou parasitaire). Deux petits vers ronds très voisins, Ancylostoma duodenale et Necator americanus, sont désignés couramment par le ''même nom'' d''''ankylostome''' car ils entraînent, par leur présence dans le duodéno-jéjunum de l'animal, ''une seule et même maladie'' : l''''ankylostomose'''.

== Morphologie ==
Très petits vers ronds d'une teinte blanchâtre ou rosée, plus effilés vers l'avant, les ankylostomes mesurent seulement {{Unité|1|cm}} pour le mâle et {{Unité|1.5|cm}} pour la femelle ; une capsule buccale fortement armée garnit leur tête. Le dimorphisme sexuel est net, la femelle se terminant en pointe (mousse?) alors que l'extrémité postérieure du mâle s'évase en une bourse copulatrice.

== Biologie ==
Les adultes vivent dans le duodéno-jéjunum (partie de l'intestin grêle qui fait suite au duodénum) ; fixés par leurs crochets buccaux à la muqueuse qu'ils &quot;broutent&quot;, ils peuvent vivre des années, 5 et plus, et leur nombre peut être considérable chez un même animal, 500 à {{formatnum:3000}}. Ils se nourrissent de sang dont ils assimilent le plasma.

Après fécondation, la femelle se met à pondre, dans la lumière intestinale, une moyenne de {{formatnum:10000}} œufs par jour ; ces œufs, émis avec les selles, ont, à ce moment, un aspect caractéristique (indifférenciable pour A. duodénale et N. americanus) : ellipsoïdes, à coque mince, ils mesurent 60 microns sur 40 microns et contiennent 4 à 8 blastomères.

Le cycle évolutif est à un seul hôte, mais avec stade de vie obligatoire, avec stade libre et migration. Arrivés dans un milieu favorable (terre humide) avec la selle qui les contient, les œufs terminent leur évolution et laissent sortir une larve qui, après deux mues, devient la larve strongyloïde enkystée infectieuse. Fuyant la terre, cette larve grimpe sur les herbes humides, jusqu'à {{Unité|30|cm}}, et y attend le passage de son hôte définitif qui arrive à son contact, elle s'y fixe, la traverse et, par voie sanguine ou lymphatique, gagne le cœur droit et le poumon ; passant dans un [[alvéole]], elle remonte les voies aériennes, atteint le carrefour aéro-digestif, est déglutie, descend jusqu'au duodénum où elle se fixe à la muqueuse et devient adulte. Entre la pénétration transcutanée et la première ponte de la femelle, 5 à 6 semaines s'écoulent.

Il faut savoir que certaines conditions sont nécessaires à l'obtention du cycle libre : apport d'œufs par défécation au grand air; terre humide, riche, chaude et ombragée, celle des bourbiers des sous-bois. Ainsi s'explique la distribution géographique : énormes foyers endémiques des régions tropicales et subtropicales, foyers localisés ou sporadiques des climats tempérés.

== Clinique ==
Paradoxalement, les aspects cliniques de l''''ankylostomose''' ont été, tout d'abord, décrits en Europe, a pratiquement disparu grâce à des mesures de surveillance draconiennes ; pourtant les bouffées sporadiques apparaissant, montrent la nécessité du maintien de ces mesures. '''Trois tableaux cliniques se succèdent''' dans l'ankylostomose, les deux premiers traduisant l'action des stades larvaires, le dernier, celle des adultes :

;La période d'infestation :
La période d'infestation, lors de la pénétration trans-cutanée des larves, a un tableau de dermatose : ''la gale de terre'' ; aux pattes surtout, dans les espaces interdigitaux, au pli du coude, ce sont des piqûres suivies de chatouillements, puis apparaissent des maculopapules, des placards érythémateux, durant de quelques heures à quelques jours ; les réinoculations constantes et les lésions de grattage en font une dermatose chronique avec eczématisation, lichénification aboutissant, aux nodules rouges sous les tropiques, aux suppurations et au phagédénisme.

;La période d'invasion :
La période d'invasion, pendant le transit des larves à travers l'appareil respiratoire, avec un tableau d'affection broncho-pulmonaire, se ramène à un syndrome de Löffler atypique : pseudo-bronchite avec toux quinteuse et voix rauque, sans signes d'auscultation ; absence d'infiltrats pulmonaires labiles à la radiographie, sauf dans quelques infestations très massives ; crises urticariennes ; hyperleucocytose avec éosinophilie élevée à 40 % et plus. Cette période débute vers le 8{{e}} jour après le contage.

;La période d'état :
Le période d'état, 8 à 15 jours plus tard, est celle du parasitisme intestinal par les vers adultes ; c'est l'ankylostomose proprement dite dont le tableau traduit 4 ordres de troubles : digestifs, anémiques, nerveux et généraux.
* '''Les troubles digestifs''' consistent en gêne épigastrique, douleurs épigastriques irradiant vers l'épaule gauche ou la fosse iliaque gauche, calmées ou exacerbées par la prise d'aliments ; troubles dyspeptiques constants, avec modification de l'appétit, inappétence et faims nerveuses amenant aux perversions du goût et au géophagisme ; régurgitations, nausées, aérogastrie ; puis, plus tard, troubles intestinaux : météorisme abdominal, alternance de diarrhées et de constipation, puis de selles pâteuses et de diarrhée séreuse, enfin melaena dû à la fois au sang provenant des lésions et aux hématies rejetées par les vers.
* '''Les troubles anémiques''', constants, s'installent insidieusement : sécheresse de la peau ; décoloration des muqueuses ; œdème péri-malléolaire remontant le long du membre inférieur ; accélération du pouls, palpitations, dyspnée d'effort, bourdonnements d'oreille, vertiges et épistaxis. L'auscultation permet d'entendre, dans un cœur dilaté, des souffles anémiques. L'exament du sang montre : une chute du taux des hématies à 1 million ou moins, avec polychromatophilie, anisocytose, microcytose, réticulocytes et anneaux de Cabot ; une hypochromie avec taux d'hémoglobine inférieur à 25 % ; une leucocytose modérée, mais une éosinophilie revenue vers 10 à 20 %. Cette anémie peut aboutir à des cardiopathies diverses.
* '''Les troubles nerveux''' sont fréquents : céphalées et insomnie ; troubles paresthésiques, engourdissements, fourmillements, refroidissement des membres ; troubles moteurs, hypotonie musculaire, troubles de la marche avec ébauche d'incoordination motrice, puis abolition des réflexes ; amyotrophie importante qui, masquée par l'œdème, doit être recherchée soigneusement. Parfois on arrive au type polynévritique et à des paraplégies.
* '''Les troubles généraux''' consistent en poussées fébriles à 38 - {{Unité|38.5|°C}}, crises polyuriques avec légère albuminurie, aménorrhée, arrêt de la croissance et de l'évolution psychique chez les chiots, diminution intellectuelle avec amnésie, aboulie et dépression mentale chez l'adulte.

== Évolution ==
L'évolution dépend de l'intensité du parasitisme et du mode de vie du malade : les sujets avec moins de 25 vers sont des porteurs sains, les malades hébergeant de 25 à 500 vers sont améliorables par le traitement, ceux qui dépassent ce chiffre et arrivent à des taux de {{formatnum:3000}} et plus font une forme dite maligne, à pronostic très sombre, amenant à la cachexie et la mort par affection intercurrente. De même, alors qu'un autre chien, infecté accidentellement à son passage en zone d'endémie, sera spontanément déparasité à 80 % en un an dès son retour en région saine d'un foyer important, dont la faune parasitaire va augmenter régulièrement de 50 vers par an sous l'influence des réinfestations constantes, s'achemine inéluctablement vers une forme maligne aboutissant à la cachexie et à la mort.

== Diagnostic ==
Le diagnostic des deux premières périodes se fait rarement sans la notion de contage possible, dans une zone d'endémie ; à la période d'état, le diagnostic clinique est surtout celui des anémies. La constatation d'une éosinophilie élevée, atteignant 60 à 70 % au cours du premier mois, doit faire rechercher une parasitose ; le diagnostic de certitude sera donné par la découverte des œufs caractéristiques dans les selles (par examen direct ou après enrichissement) et surtout par celles des larves après coproculture qu'il faut demander expressément au laboratoire.

== Traitement ==
L'ankylostome peut être traité localement par cryothérapie quand il est toujours dans la peau. Le Mébendazole ({{Unité|100|mg}} 2 fois par jour pendant 3 jours) est efficace à l'étape intestinale et pendant l'étape où le parasite migre toujours sous la peau. En cas d'anémie, la supplémentation en fer peut atténuer les symptômes de l'anémie ferriprive. Cependant, lorsque le taux de globules rouges revient à la normale, le manque d'autres substances comme l'acide folique ou la vitamine B12 peut apparaître qui peuvent également nécessiter une supplémentation. Chez les chiots, après le déparasitage, une amélioration de l'état de santé est constatée dans les deux mois, et après un an, les formules sanguines sont redevenues normales.

== Prévention, prophylaxie individuelle et hygiène ==
La médication a progressé, et certains succès ont été obtenus, avec la proposition de moyens de suivi et de prévention, notamment chez les chiots. Nettoyage et séchage immédiat et vigoureux de la peau en cas de contact avec la boue. Des cartes de risques peuvent être faites et diffusées. Cependant, après les campagnes de médication, le risque de réinfection est toujours élevé en zone d'endémie. On a montré que l'éducation à l'hygiène était nécessaire, de même que la prise en compte su contexte socioéconomique des propriétaires et groupes concernés. Les campagnes massives même sur 10 ans de vermifugeage sont suivies d'une reprise des infestations sans mesures strictes d'hygiène.

== Aspects zoonotiques ==
Une étude récente (2012) a utilisé en Malaisie des moyens d'analyse classiques et moléculaires permettant de discriminer les différentes espèces d'ankylostome, ce que ne permet pas l'examen microscopique classique des selles. Des outils épidémiologiques ont été associés pour déterminer le rôle possible des animaux domestiques. L'étude a confirmé que l'infection par ''Ancylostoma ceylanicum'' est fréquente chez les populations humaines en Malaisie et que les chiens et chats contribuent à la propagation et transmission de l'ankylostome dans les communautés pauvres.

[[Catégorie:Cynologie (livre)]]</text>
      <sha1>qgmoa9h0wdsund673f0yksfjcu8wzgn</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation VBScript/Fonctions</title>
    <ns>0</ns>
    <id>56350</id>
    <revision>
      <id>684241</id>
      <parentid>483934</parentid>
      <timestamp>2022-08-27T12:53:26Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5977" xml:space="preserve">{{VBS}}

== conversion et mise en forme ==
*CBool(expr) - ''conversion en variant booleen''
*CByte(expr) - ''conversion en variant byte''
*CCur(expr) - ''conversion en variant currency''
*CDate(expr) - ''conversion en variant date''
*CDbl(expr) - ''conversion en variant double''
*CInt(expr) - ''conversion en variant integer''
*CLng(expr) - ''conversion en variant long''
*CSng(expr) - ''conversion en variant single''
*CStr(expr) - ''conversion en variant string''
*FormatCurrency(expr,[NumDigitsAfterDecimal],[IncludeLeadingDigit],[UseParensForNegativeNumber],[GroupDigits]) - ''conversion formatée en variant currency''
*FormatDateTime(date,[NamedFormat]) - ''conversion formatée en variant date''
*FormatNumber(expr,[NumDigitsAfterDecimal],[IncludeLeadingDigit],[UseParensForNegativeNumber],[GroupDigits]) - ''conversion formatée en variant nombre'' 
*FormatPercent(expr,[NumDigitsAfterDecimal],[IncludeLeadingDigit],[UseParensForNegativeNumber],[GroupDigits]) - ''conversion formatée en variant percent''
*Hex(nbr) - ''conversion en variant hexadecimal''
*IsArray(expr) - ''renvoit booleen si tableau''
*IsDate(expr) - ''renvoit booleen si date''
*IsEmpty(expr) - ''renvoit booleen si vide''
*IsNull(expr) - ''renvoit booleen si null''
*IsNumeric(expr) - ''renvoit booleen si nbr''
*IsObject(identifier) - ''renvoit booleen si obj automation''
*Oct(nbr) - ''conversion en string octal''

== mathématiques ==
*Abs(nbr) - ''renvoie valeur absolue''
*Atn(nbr) - ''renvoie arc tangent''
*Cos(nbr) - ''renvoie cosinus''
*Exp(nbr) - ''renvoie la puissance''
*Int(nbr) - ''renvoie partie entière''
*Fix(nbr) - ''renvoie partie entière''
*Log(nbr) - ''renvoie log népérien''
*Sqr(nbr) - ''renvoie racine carrée''
*Tan(nbr) - ''renvoie tangente''
*Sgn(nbr) - ''renvoie signe''
*Randomize(nbr) - ''init nbr aleatoire !!les nombres ne sont pas aleatoire en vbs!!''
*Rnd(nbr) - ''renvoie nbr aleatoire''
*Round(expr,[numdecimalplaces]) - ''renvoie l'arrondi''
*Sin(nbr) - ''renvoie sinus''

== de traitement de chaînes ==
*Asc(string) - ''renvoie code ansi du 1er char''
*Chr(charcode) - ''renvoie le char du code ansi''
*inStr(start,string,string2,[compare]) - ''renvoie 1ère position d'un string dans un autre''
*InStrRev(delimiter) - ''renvoie position d'un string dans un autre en partant de fin''
*Join(string) - ''renvoie string joins partant d'un tableau''
*LCase(string) - ''conversion en minuscule''
*Left(string,length) - ''renvoie sous string partant de gauche''
*Len(string) - ''renvoie nbr de char dans string''
*LTrim(string) - ''renvoie string sans espace à gauche''
*Mid(string,start,[length]) - ''renvoie sous string partant de milieu''
*Replace(expr,find,replacement,[start],[count],[compare]) - ''remplace string dans string''
*Right(string,length) - ''renvoie sous string partant de droite''
*RTrim(string) - ''renvoie string sans espace à droite''
*StrComp(string1,string2,[compare]) - ''renvoie valeur de comparaison de string''
*String([nbr],[char]) - ''renvoie string de char repete''
*StrReverse(string) - ''renvoie string inverse''
*Space(nbr) - ''renvoie string de space''
*Trim(string) - ''renvoie string sans espace ni gauche ni droite''
*UCase(string) - ''renvoie string en majuscule''

== de date et d'heure ==
*Date() - ''renvoie date sys''
*DateAdd(interval,nbr,Date) - ''renvoie date + interval''. Ex : &lt;code&gt;DateAdd(&quot;d&quot;, -1, now)&lt;/code&gt; affiche la date de la veille.
*DateDiff(interval,date1,date2,[firstdayofweek],[firstdayofyear]) - ''renvoie interval''
*DatePart(interval,Date,[firstdayofweek],[firstdayofyear]) - ''renvoie partie spécifiée''
*DateSerial(Year,Month,Date) - ''renvoie variant de type date''
*DateValue(Date) - ''renvoie variant de type date''
*Day(Date) - ''renvoie jour du mois''
*Hour(Time) - ''renvoie heure''
*Minute(Time) - ''renvoie minute''
*Month(Date) - ''renvoie mois en chiffre''
*MonthName(Month,[abbreviate]) - ''renvoie mois en lettre''
*Now() - ''renvoie date et heure sys''
*Second(Time) - ''renvoie seconde''
*Time() - ''renvoie heure sys''
*Timer() - ''renvoie nbre de sec depuis 00:00''
*TimeSerial(Hour,Minute,Second) - ''renvoit variant de type date''
*TimeValue(Time) - ''renvoit variant de type date''
*Weekday(Date,[fistdayofweek]) - ''renvoie jour semaine en chiffre''
*WeekdayName(Weekday,abbreviate,firstdayofweek) - ''renvoie jour semaine en lettre''
*Year(Date) - ''renvoie annee de date''

== liées aux tableaux ==

*Array(arg) - ''renvoie variant contenant tableau''
*Erase tableau - ''libère tableau''
*Filter(InputStrings,Value,[Include],[compare]) - ''renvoie tableau commençant par 0 contenant sous ensemble de string''
*LBound(arrayname,[dimension]) - ''renvoie plus petit indice tableau''
*Split(expr,[delimiter],[count],[compare]) - ''renvoie tableau commençant par 0 comprenant # de string''
*UBound(arrayname,[dimension]) - ''renvoie plus grand indice tableau''

== Autres fonctions ==
*CreateObject(class) - ''renvoie ref à objet automation''
*Eval(string) - ''renvoie resultat''
*Execute ins - ''execute ins''
*ExecuteGlobal ins - ''execute ins globale''
*GetLocale() - ''renvoie valeur ID parametre regionnaux sys''
*GetObject([pathname],[class]) - ''renvoie ref à objet automation de fichier''
*GetRef(string) - ''renvoie ref à procedure''
*InputBox(prompt,[title],[default],[xpos],[ypos],[helpfile],[context]) - ''prompt''
*LoadPicture([stringexpr) - ''renvoie img''
*MsgBox(prompt,[buttons],[title],[helpfile],[context]) - ''msgbox''
*RGB(red,green,blue) - ''renvoie int rgb''
*ScriptEngine() - ''renvoie string de script utilisé''
*ScriptEngineBuildVersion() - ''renvoie N° version''
*ScriptEngineMajorVersion() - ''renvoie N° version principale''
*ScriptEngineMinorVersion() - ''renvoie N° version secondaire''
*SetLocate(Icid) - ''def param regionnaux globaux''
*TypeName(varname) - ''renvoit string d'info sur variant''
*VarType(varname) - ''renvoit valeur sous type de var''

Pour déclarer ses propres fonctions, voir le chapitre [[../Application/]].</text>
      <sha1>t96i6r5zev0ez9ad1bquzqdgu2tgufg</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Visual Basic .NET/Premier script</title>
    <ns>0</ns>
    <id>56498</id>
    <revision>
      <id>684247</id>
      <parentid>683569</parentid>
      <timestamp>2022-08-27T12:57:55Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1940" xml:space="preserve">&lt;noinclude&gt;{{VB.NET}}&lt;/noinclude&gt;

== Application Windows Forms ==
Pour commencer à programmer en Visual Basic .NET, lancer l'interface choisie dans le premier chapitre et créer un nouveau projet de type ''Application Windows Forms''.

Double-cliquer sur le formulaire vierge pour faire apparaitre son code dans un autre onglet, qui doit être une classe vierge :

&lt;syntaxhighlight lang=&quot;vbnet&quot;&gt;
Public Class Form1
    Inherits System.Windows.Forms.Form

[Windows Form Designer generated code]

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

    End Sub
End Class
&lt;/syntaxhighlight&gt;

Y ajouter la ligne suivante dans la fonction ''Form_Load'' (entre les lignes ''Private Sub'' et ''End Sub'') :

&lt;syntaxhighlight lang=&quot;vbnet&quot;&gt;
 MessageBox.Show(&quot;Hello World!&quot;)
&lt;/syntaxhighlight&gt;

En pressant F5 ou en cliquant dans le menu ''Debug'' sur ''Démarrer le programme'', cela devrait afficher une boite contenant le message &quot;Hello World!&quot;, qui si on clique dessus laisse place au formulaire vierge. On peut le fermer ensuite avec le bouton de croix en haut à droite.


== Application console ==
Ajouter un projet via le menu ''File'', puis ''New'', et ''Project...'' puis sélectionner ''Application console''.

Ajouter dans la fonction ''Main()'' :
&lt;syntaxhighlight lang=&quot;vbnet&quot;&gt;
 Console.WriteLine(&quot;Hello World!&quot;)
 Console.ReadLine()
&lt;/syntaxhighlight&gt;

Pour que l'exécution du programme ne déclenche plus le formulaire du paragraphe précédent, mais la console à la place, effectuer un clic droit sur la nouvelle ''ConsoleApplication1'' dans l’''Explorateur de solutions'', puis ''Définir comme projet de démarrage''.

Ensuite en pressant F5 la console se lance.

== Symboles de base ==
Tout comme en Visual Basic, VB.net utilise :
# ' avant les commentaires
# _ pour scinder une commande sur la ligne suivante
# : pour démarrer une nouvelle commande sur la même ligne.</text>
      <sha1>l10c57gxkq09jyb6i5exdtclf70oiji</sha1>
    </revision>
  </page>
  <page>
    <title>Technologie/Lignes et services de métros/Prolongements et créations de lignes de métros en Île-de-France/Fusion des lignes 3bis et 7bis</title>
    <ns>0</ns>
    <id>56596</id>
    <revision>
      <id>684283</id>
      <parentid>641875</parentid>
      <timestamp>2022-08-27T18:22:29Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6715" xml:space="preserve">{{chapeau Lignes et services de métros}}


&lt;div style=&quot;text-align: center;&quot;&gt;[[File:Metro-M.svg|250px]] [[File:Paris m 3bis jms.svg|250px]] [[File:Paris m 7bis jms.svg|250px]]&lt;/div&gt;

= '''La fusion des lignes 3bis et 7bis'''=

Une fusion des lignes bis du réseau de métros est projetée pour former une ligne dont le numéro n'est pas encore choisi. Elle devrait réutiliser la voie des fêtes (ouverte en 1921, jamais utilisée) et la voie navette (ouverte a la même date, elle n'a pas été utilisée depuis 56(essais du métro pneumatique)). La voie des fêtes fera la liaison entre la porte des Lilas et la place des fêtes en ouvrant (car elle n'a jamais été ouverte, ce qui oblige à créer des accès) la station Haxo, la voie navette, elle, reliera la porte des Lilas au Pré-Saint-Gervais. En fusionnant les deux lignes, les quais de la station Porte des Lilas de la ligne 3 bis seront abandonnés et la station [[w:Porte des Lilas cinéma|Porte des Lilas cinéma]] (utilisée jusqu'à maintenant seulement pour le cinéma) sera ouverte au voyageur.


== '''Plan de la ligne fusionnée''' ==

{| cellspacing=0 cellpadding=2 border=&quot;0&quot; style=&quot;border: 1px solid #999; background-color:#FFFFFF; text-align: center&quot;
|- bgcolor=&quot;#CCCCCC&quot;
!&amp;nbsp;!!&amp;nbsp;!!&amp;nbsp;!!&amp;nbsp;!!&amp;nbsp;!! Station !! Communes desservies !! Correspondances
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| ''[[w:Château-Landon (métro de Paris)|Château-Landon]]'' &lt;small&gt;(nouvelle station)&lt;/small&gt;
| [[w:10e arrondissement de Paris|10{{e}}]]
| align=left | 	[[File:Metro-M.svg|20px]] [[File:Paris m 7 jms.svg|20px]]&lt;br /&gt;([[w:Gare de l'Est (métro de Paris)|Gare de l'Est]]:)&lt;br /&gt;[[File:Metro-M.svg|20px]] [[File:Paris m 4 jms.svg|20px]][[File:Paris m 5 jms.svg|20px]]&lt;br /&gt; &lt;br /&gt;[[File:RER.svg|20px]][[File:Paris RER E icon.svg|20px]] ([[w:Gare de Magenta|Magenta]]) &lt;small&gt;(à distance)&lt;/small&gt; &lt;br /&gt;[[File:Logo train transilien.svg|20px]] [[File:Logo Paris Transilien ligneP.svg|20px]]&lt;br /&gt;[[File:TGV.svg|40px]]
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Louis Blanc (métro de Paris)|Louis Blanc]]
| [[w:10e arrondissement de Paris|10{{e}}]]
| align=left | 	[[File:Metro-M.svg|20px]] [[File:Paris m 7 jms.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Jaurès (métro de Paris)|Jaurès]]
| [[w:10e arrondissement de Paris|10{{e}}]], [[w:19e arrondissement de Paris|19{{e}}]]
| align=left | 	[[File:Metro-M.svg|20px]] [[File:Paris m 2 jms.svg|20px]] [[File:Paris m 5 jms.svg|20px]]
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Bolivar (métro de Paris)|Bolivar]]
| [[w:19e arrondissement de Paris|19{{e}}]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Buttes Chaumont (métro de Paris)|Buttes Chaumont]]
| [[w:19e arrondissement de Paris|19{{e}}]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#8fc31f&quot;| &amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Botzaris (métro de Paris)|Botzaris]]
| [[w:19e arrondissement de Paris|19{{e}}]]
| align=left |
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&lt;span style=&quot;color:black&quot;&gt;⇃&lt;/span&gt; || bgcolor=&quot;#8fc31f&quot; |&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot;|&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&lt;span style=&quot;color:black&quot;&gt;↾&lt;/span&gt;
| [[w:Danube (métro de Paris)|Danube]]
| [[w:19e arrondissement de Paris|19{{e}}]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Place des Fêtes (métro de Paris)|Place des Fêtes]]
| [[w:19e arrondissement de Paris|19{{e}}]]
| align=left | 	[[File:Metro-M.svg|20px]] [[File:Paris m 11 jms.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Pré Saint-Gervais (métro de Paris)|Pré Saint-Gervais]]
| [[w:19e arrondissement de Paris|19{{e}}]]
| align=left | 	
|-
| bgcolor=&quot;#ffffff&quot;|&lt;span style=&quot;color:black&quot;&gt;⇃&lt;/span&gt; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&lt;span style=&quot;color:black&quot;&gt;↾&lt;/span&gt;
| ''[[w:Haxo (métro de Paris)|Haxo]]'' &lt;small&gt;(nouvelle station)&lt;/small&gt;
| [[w:19e arrondissement de Paris|19e]]
| align=left | 	[[File:Paris logo tram jms.svg|20px]] [[File:Logo Paris tram ligne3b.svg|20px]]
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#8fc31f&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Porte des Lilas (métro de Paris)|Porte des Lilas]]
| [[w:19e arrondissement de Paris|19{{e}}]], [[w:20e arrondissement de Paris|20{{e}}]] 
| align=left |	[[File:Metro-M.svg|20px]] [[File:Paris m 11 jms.svg|20px]]&lt;br /&gt;[[File:Paris logo tram jms.svg|20px]] [[File:Logo Paris tram ligne3b.svg|20px]]
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Saint-Fargeau (métro de Paris)|Saint-Fargeau]] 
| [[w:20e arrondissement de Paris|20{{e}}]]
| align=left |  
|- bgcolor=&quot;#efefef&quot;
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Pelleport (métro de Paris)|Pelleport]] 
| [[w:20e arrondissement de Paris|20{{e}}]]
| align=left |
|-
| bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#8fc31f&quot; |&lt;span style=&quot;color:black&quot;&gt;o&lt;/span&gt; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp; || bgcolor=&quot;#ffffff&quot;|&amp;nbsp;
| [[w:Gambetta (métro de Paris)|Gambetta]]
| [[w:20e arrondissement de Paris|20{{e}}]]
| align=left | [[File:Metro-M.svg|20px]] [[File:Paris m 3 jms.svg|20px]]
|}
[[File:Haxo (Paris Metro).png|thumb|1000px|Plan des liaisons créées et supprimées]]
﻿</text>
      <sha1>pus3lo5draqn4rr1gtfvmlkewdkdccz</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Introduction</title>
    <ns>0</ns>
    <id>57640</id>
    <revision>
      <id>684290</id>
      <parentid>680534</parentid>
      <timestamp>2022-08-27T18:28:08Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>ceinture et bretelles...</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8564" xml:space="preserve">&lt;noinclude&gt;{{Programmation Python}}&lt;/noinclude&gt;

== Définition du langage ==
Python est un langage de script de haut niveau, structuré et open source. Il est [[w:Paradigme_(programmation)|multi-paradigme]] et multi-usage.

Développé à l'origine par {{w|Guido van Rossum}} en 1989&lt;ref&gt;http://python-history.blogspot.fr/2009/01/brief-timeline-of-python.html&lt;/ref&gt;, il est, comme la plupart des applications et outils open source, maintenu par une équipe de développeurs un peu partout dans le monde.

Conçu pour être [[Programmation/Programmation orientée objet|orienté objet]], il n'en dispose pas moins d'outils permettant de se livrer à la [[w:programmation fonctionnelle|programmation fonctionnelle]] ou [[Programmation impérative|impérative]] ; c'est d'ailleurs une des raisons qui lui vaut son appellation de « langage agile ».

Parmi les autres raisons, citons la rapidité de développement (qualité propre aux langages interprétés), la grande quantité de modules fournis dans la distribution de base ainsi que le nombre d'interfaces disponibles avec des bibliothèques écrites en [[Programmation C|C]], [[Programmation C++|C++]] ou [[Programmation Fortran|Fortran]]. Il est également apprécié pour la clarté de sa syntaxe, ce qui l'oppose au langage [[Programmation Perl|Perl]].

=== Caractéristiques du langage ===

Détaillons un peu les principales caractéristiques de Python, plus précisément, du langage et de ses deux implantations actuelles :

* Python est ''portable'', non seulement sur les différentes variantes d'''Unix'', mais aussi sur les OS propriétaires: ''MacOS'', ''BeOS'', ''NeXTStep'', ''MS-DOS'' et les différentes variantes de ''Windows''. Un nouveau compilateur, baptisé ''Jython'', est écrit en Java et génère du bytecode Java.

* Python est ''gratuit'', mais on peut l'utiliser sans restriction dans des projets commerciaux.

* Python convient aussi bien à des ''scripts'' d'une dizaine de lignes qu'à des ''projets complexes'' de plusieurs dizaines de milliers de lignes.

* La ''syntaxe de Python est très simple'' et, combinée à des ''[[Programmation/Types|types]] de données évolués'' (listes, dictionnaires,...), conduit à des programmes à la fois très compacts et très lisibles. À fonctionnalités égales, un programme Python (abondamment commenté et présenté selon les canons standards) est souvent de 3 à 5 fois plus court qu'un programme ''C'' ou ''C++'' (ou même ''Java'') équivalent, ce qui représente en général un temps de développement de 5 à 10 fois plus court et une facilité de maintenance largement accrue.

* Python gère ses ressources (mémoire, descripteurs de fichiers...) sans intervention du programmeur, par un mécanisme de ''comptage de références'' (proche, mais différent, d'un ramasse-miettes).

* Il n'y a ''pas de pointeurs'' explicites en Python.

* Python est (optionnellement) ''multi-threadé''.

* Python est ''orienté-objet''. Il supporte l'''{{wt|héritage multiple}}'' et la ''{{wt|surcharge}} des opérateurs''. Dans son modèle objets, et en reprenant la terminologie de C++, toutes les méthodes sont virtuelles.

* Python intègre, comme ''Java'' ou les versions récentes de ''C++'', un système d'''exceptions'', qui permettent de simplifier considérablement la gestion des erreurs.

* Python est ''dynamique'' (l'interpréteur peut évaluer des chaînes de caractères représentant des expressions ou des instructions Python), ''orthogonal'' (un petit nombre de concepts suffit à engendrer des constructions très riches), ''réflectif'' (il supporte la métaprogrammation, par exemple la capacité pour un objet de se rajouter ou de s'enlever des attributs ou des méthodes, ou même de changer de classe en cours d'exécution) et ''introspectif'' (un grand nombre d'outils de développement, comme le ''debugger'' ou le ''profiler'', sont implantés en Python lui-même).

* Comme ''[[Programmation Scheme|Scheme]]'' ou ''SmallTalk'', Python est dynamiquement typé. Tout objet manipulable par le programmeur possède un type bien défini à l'exécution, qui n'a pas besoin d'être déclaré à l'avance.

* Python possède actuellement deux implémentations. L'une, ''interprétée'', dans laquelle les programmes Python sont compilés en instructions portables, puis exécutés par une machine virtuelle (comme pour ''Java'', avec une différence importante: ''Java'' étant statiquement typé, il est beaucoup plus facile d'accélérer l'exécution d'un programme Java que d'un programme Python). L'autre génère directement du ''bytecode Java''.

* Python est ''extensible'' : comme ''Tcl'' ou ''[[Guile]]'', on peut facilement l'interfacer avec des bibliothèques ''[[Programmation C|C]]'' existantes. On peut aussi s'en servir comme d'un langage d'extension pour des systèmes logiciels complexes.

* La ''bibliothèque standard'' de Python, et les paquetages contribués, donnent accès à une grande variété de services : chaînes de caractères et expressions régulières, services ''UNIX'' standards (fichiers, ''pipes'', signaux, sockets, threads...), protocoles Internet (''Web'', ''News'', ''{{wt|FTP}}'', ''{{wt|CGI}}'', ''[[Programmation HTML|HTML]]''…), [[w:Persistance_(informatique)|persistance]] et bases de données, interfaces graphiques.

* Python est un langage qui ''continue à évoluer'', soutenu par une communauté d'utilisateurs enthousiastes et responsables, dont la plupart sont des supporters du logiciel libre. Parallèlement à l'interpréteur principal, écrit en ''C'' et maintenu par le créateur du langage, un deuxième interpréteur, ''{{w|Jython}}'', écrit en ''Java'', est en cours de développement.

* Enfin, Python est un langage de choix pour traiter le ''[[Programmation XML|XML]]''.

== Utilisation ==
Comme mentionné plus haut, Python se prête à un grand nombre de tâches. La distribution de base permet, entre autres, des développements réseau, la création d'interfaces graphiques (via tcl/tk), de la programmation cgi, de traiter du [[Programmation XML|XML]], etc. Sa relative facilité d'interfaçage avec des bibliothèques écrites en d'autres langages en fait un outil de choix pour des applications de calcul scientifique. Il est également de plus en plus utilisé comme langage de prototypage.

Python est aussi remarquable pour le nombre de bibliothèques accessibles via l'installation des modules appropriés. Que ce soit la connexion avec une base de données, l'utilisation de bibliothèques d'interface graphique (wxPython, PyQt, pyGTK), la manipulation avancée de [[Programmation XML|XML]] (pyXML), le traitement d'image (Python Imaging Library), le développement de jeu vidéo (pygame), [[Programmation OpenGL|OpenGL]], la grande majorité des technologies actuelles dispose de son extension Python.&lt;/p&gt;

=== Quelques exemples d'utilisation de Python ===
*Le serveur d'application Zope
*Administration du moteur de recherche Google
*Administration des fermes de rendu de la société d'effets spéciaux ILM
*l'application de dessin vectoriel Skencil (anciennement Sketch)
*Boa constructor, outil de développement rapide d'applications wxPython

D'autres exemples sont disponibles sur [http://pythonology.org/success Python success stories (anglais)]

== Version 2 et version 3 ==

Il est à noter que les deux principales familles de python sont la famille version 2 et la famille version 3.

La version 2 a été publiée en 2000.
Lorsqu'il est nécessaire de modifier des anciens code, ou d'utiliser des anciennes librairies, il peut être utile d'apprendre la version 2.
Cependant le support de Python 2 est fini depuis le 1er janvier 2020&lt;ref&gt;https://www.python.org/doc/sunset-python-2/&lt;/ref&gt;.

Il vaut mieux donc apprendre Python 3, version publiée en 2006, puis éventuellement apprendre les différences entre les versions 2 et 3.

=== Différences entre Python 2 et 3 ===
* En Python 3, l'Unicode est l'encodage par défaut, alors qu'en 2 il faut préfixer les chaînes par &quot;u&quot; pour y placer des caractères accentués. Pour écrire des chaînes compatibles dans les deux langages, on utilisera donc &lt;code&gt;from __future__ import unicode_literals&lt;/code&gt; en Python 2.
* En Python 3, on remplace &lt;code&gt;raw_input()&lt;/code&gt; par &lt;code&gt;input()&lt;/code&gt;.
* En Python 3, on force l'utilisation des parenthèses à &lt;code&gt;print()&lt;/code&gt; qui est désormais une fonction au lieu d'un mot clé.
* En Python 3, on force &lt;code&gt;except Exception as e:&lt;/code&gt; au lieu de &lt;code&gt;except Exception, e:&lt;/code&gt;.

== Références ==
{{Références}}</text>
      <sha1>qfvvaszxal8mxp23u7bhpai9q2yiil6</sha1>
    </revision>
  </page>
  <page>
    <title>Psychologie cognitive pour l'enseignant/Le changement conceptuel</title>
    <ns>0</ns>
    <id>57851</id>
    <revision>
      <id>684249</id>
      <parentid>673963</parentid>
      <timestamp>2022-08-27T14:46:49Z</timestamp>
      <contributor>
        <username>Romanc19s</username>
        <id>3047</id>
      </contributor>
      <comment>Orthographe &quot;ont subIII&quot;</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25507" xml:space="preserve">{{Psychologie cognitive pour l'enseignant}}

{{citation bloc|Tu dois désapprendre tout ce que tu as appris.}}

Cette maxime de maître Yoda peut sembler saugrenue. Après tout, pourquoi désapprendre ce qu'on a mis tant de temps à apprendre ? C'est d'autant plus étrange pour les professeurs et formateurs, qui n'aimeraient pas que leur travail n'ait servi à rien. Cependant, il est des situations où il faut désapprendre des informations erronées. Et cela est beaucoup plus dur qu'on ne pourrait le penser. Remplacer des connaissances inadaptées ou obsolètes par des connaissances plus appropriées est souvent un véritable calvaire qui demande beaucoup de temps. Dans de nombreuses situations, des connaissances antérieures inadaptées ne s'oublient pas, elles se cristallisent, et persistent. Pire : elles peuvent empêchent la compréhension de nouvelles idées. L'acquisition de connaissance étant fortement cumulative, toute conception erronée va faire office de grain de sable dans une machine bien huilée. Difficile de façonner un château sur des fondations branlantes. Mais qu'on se rassure : la recherche a étudié le remplacement de connaissances erronées par des connaissances plus adéquates.

==Les conceptions erronées==

Dans la littérature anglaise, les connaissances antérieures inadaptées sont appelés des '''misconceptions''', ce que l'on peut traduire en français par '''conceptions erronées''' ou, plus simplement, par '''idées fausses'''. Elles sont très nombreuses et elles sont loin de toutes se ressembler. Chose intéressante, certaines idées fausses sont récurrentes, présentes chez un très grand nombre d'élèves. Par exemple, n'importe quel élève assez jeune croira que les corps tombent dans le vide à une vitesse qui dépend de leur poids (alors qu'en fait, tous les corps tombent à la même vitesse dans le vide). Connaître à l'avance ces conceptions est clairement un gros plus.

Le terme &quot;idée fausse&quot; regroupe des situations très différentes, allant de simples faits erronés faciles à corriger à des erreurs très élaborées, très difficiles à éradiquer. Pour simplifier, nous allons faire la distinction entre les conceptions simples et les conceptions élaborées. La différence est que les premières portent sur une connaissance isolée, alors que les secondes portent sur des connaissances centrales, fortement connectées à d'autres, qui sont la base d'un réseau de connaissances variées. Les conceptions simples peuvent se corriger simplement en corrigeant la connaissance erronée, alors que les conceptions complexes se corrigent lentement et assez mal.

===Les conceptions simples===

Les conceptions simples font que l'étudiant se trompe sur un détail ou un fait assez superficiel, sans grandes conséquences. L'exemple le plus classique : les faux amis en anglais ! Demandez ce que veut dire ''actually'' en anglais à un élève qui ne connaît pas ce mot : il vous répondra ''actuellement'', alors que ''actually'' veut dire ''en fait''. Comme autres exemples, on pourrait citer les jeunes enfants qui croient que le jour et la nuit sont causés par la rotation de la Terre autour du Soleil (pour les moins jeunes), que les quatre saisons proviennent de l'éloignement de la terre par rapport au soleil, ou que les premiers humains ont cohabité avec les dinosaures. De telles erreurs se corrigent assez facilement, de simples explications orales et un peu d'entrainement suffisant à résoudre le problème.

Basiquement, les conceptions simples peuvent approximativement se classer en trois types : les conceptions vernaculaires, factuelles et conceptuelles. Une classification plus détaillée ne serait pas vraiment utile, aussi nous allons nous contenter de ces trois types superficiels. Voici la classification en détail :
* Avec les erreurs vernaculaires, la conception est liée au fait qu'un mot a des sens différents, qui peuvent porter à confusion. Le cas le plus évident est celui où un terme n'a pas le même sens dans le langage courant et dans les matières scientifiques. Un exemple classique serait les termes de &quot;chaleur&quot;, &quot;force&quot;, &quot;puissance&quot; : leur sens en physique n'est pas le même que celui du langage courant. Pour un élève, accélérer signifie &quot;gagner de la vitesse&quot;, alors que cela veut dire &quot;changer de vitesse, aussi bien en gagner qu'en perdre&quot; pour le physicien. Pour le second exemple, prenons un débutant en programmation qui aborde les notions de variable et de fonction : ces deux concepts sont très différents des concepts de variables et de fonction abordés en mathématique, mais l'étudiant aura tendance à faire la confusion. Un dernier exemple serait ceux qui pensent que &quot;les schizophrènes ont une double personnalité&quot;, ce qui n'est pas du tout le cas et vient de l'utilisation du terme &quot;schizophrène&quot; dans le langage courant.
* Avec les erreurs factuelles, l'élève se trompe sur un fait précis, sans que cela ait des conséquences importantes. Le fait en question est isolé et n'est pas centrale dans la compréhension d'une discipline ou d'une théorie. Voici quelques exemples de conceptions de ce type : &quot;les vikings portaient des casques à corne&quot;, &quot;les vikings buvaient dans les crânes de leurs ennemis&quot;, &quot;les vierges de fer et les ceintures de chasteté ont réellement été utilisées au Moyen Âge&quot;, &quot;les humains n'utilisent que 10% de leur cerveau&quot;, &quot;en été, le Soleil est plus près de la Terre qu'en hiver&quot;, &quot;la mémoire d'un poisson rouge est de quelques secondes&quot;, &quot;les souris adorent le fromage&quot;, etc.
* Avec les conceptions conceptuelles, l'élève a une compréhension incomplète d'un concept. Soit parce qu'il n'a pas vu assez d'exemples, soit qu'il n'a pas vu assez d'informations sur le concept. Un tel exemple serait le cas d'un élève qui penserait que tous les volcans sont de type effusif, à savoir qu'ils émettent tous des coulées de lave rouge/orange. Un tel élève aurait une compréhension partielle du concept de volcan, par ignorance de l'existence des volcans explosifs (ceux qui émettent des cendres ou de la lave très visqueuse, parfois quasi-solide). De telles conceptions se corrigent avec un peu plus d'explications que les précédentes et/ou en ajoutant de nombreux exemples.

Les conceptions de ce genre semblent certes assez simples, mais les corriger peut avoir une grande importance, pédagogique ou non. Par exemple, prenez les conceptions suivantes : &quot;les dyslexiques sont moins intelligents que la moyenne&quot;, &quot;les vaccins causent l'autisme&quot;, &quot;les bébés ne ressentent pas la douleur&quot;. Il est évident que de telles conceptions ont fait et continuent de faire beaucoup de mal. Mais même en mettant de côté de tel extrêmes, des conceptions peuvent avoir des conséquences pédagogiques assez importantes. Par exemple, prenez la conception suivante : &quot;le Moyen Âge était une période barbare, où l'ignorance et la superstition régnaient en maitre, ce qui s'est terminé à la renaissance&quot;. Les élèves qui croient à cette conception, et ils sont nombreux, risquent d'avoir du mal à suivre des cours d'histoire et à se faire une idée claire de ce qu'était le Moyen Âge. Notons que cette conception est reliée à quelques autres, comme le fait que &quot;les paysans du Moyen Âge pensaient que la terre était plate&quot;, &quot;les paysans du Moyen Âge mourraient tous avant 40 ans&quot;, mais ces conceptions peuvent se corriger indépendamment les unes des autres sans trop de problèmes.

Les conceptions de ce type peuvent avoir des origines assez variées. Mais dans la plupart des cas, elles proviennent d'un raisonnement par induction. Quelques idées fausses de ce type naissent à partir d'analogies trompeuses, comme le montre l'exemple du mot &quot;actually&quot;. Un autre exemple serait le cas où un élève pense que les chauve-souris sont des oiseaux, car elles sont capables de voler et qu'elles ressemblent de loin à des oiseaux. D'autres proviennent de la généralisation abusive à partir d'exemples. Par exemple, beaucoup d'élèves de primaire pensent qu'une division entre deux nombres donne un résultat plus petit que le dividende, ou qu'une multiplication donne toujours un résultat plus grand que le multiplieur et multiplicande. Cette règle marche bien quand on utilise des nombres entiers naturels, mais elle ne marche plus quand on commence à manipuler des décimaux ou des fractions. Le problème est que les élèves ont acquis, consciemment ou non, cette règle en manipulant les nombres entiers et qu'ils vont la généraliser aux décimaux.

D'autres conceptions simples, plus rares, proviennent de déductions logiques, mais qui sont fausses à cause de l'ignorance d'un détail technique. Tel est le cas de la conception qui dit que &quot;le Soleil est plus près de la Terre en été et plus loin en Hiver&quot;. Une telle conception est naturelle pour qui sait que l'orbite de la Terre autour du Soleil n'est pas exactement circulaire, mais elliptique. Le problème ici est que les élèves surestiment le caractère elliptique de l'orbite de la Terre, qui est en réalité très proche d'un cercle parfait. Surestimation qui est sans doute aggravée par les représentations utilisées pour illustrer l'orbite de la Terre.

===Les conceptions élaborées===

Les conceptions élaborées ne portent pas que sur une connaissance simple, factuelle, mais portent sur tout un ensemble de connaissances fortement reliées entre elles. Les connaissances en question forment un réseau de connaissances qui se soutiennent les unes les autres. Tenter de corriger une information appartenant à ce réseau ne marchera pas. L'information corrigée sera en effet incompatible avec toutes les autres informations du réseau, et l'élève sera perdu. La correction elle-même ne s'insérera pas bien dans le réseau de connaissances préalables, elle sera incompatible avec ce qui est déjà connu.

Une bonne partie des conceptions élaborées sont des connaissances naïves tirées de l'expérience, fortement consolidées par les années, qui sont très difficiles à corriger. Généralement, quand un élève arrive à l'école, il a derrière lui plusieurs années durant lesquelles il s'est construit des modèles implicites du monde, sur les quantités, le poids et la chute des corps, les nombres, etc. Cet apprentissage par découverte &quot;naturel&quot;, dans lequel l'enfant apprend seul, entraine naturellement l'apparition d'idées fausses. Les conceptions erronées de ce genre sont très nombreuses dans l'enseignement de la physique : un kilo de plomb est plus lourd qu'un kilo de plume (confusion poids/densité), si une fusée spatiale dans le vide qui coupe ses moteurs va freiner (mauvaise compréhension du principe d’inertie), les corps tombent dans le vide à une vitesse qui dépend de leur poids, etc.

Autre exemple, un peu plus complexe : le courant électrique est souvent mal compris. Par exemple, si vous posez la question suivante aux élèves : &quot;on branche une dizaine d'ampoules en série, et une autre dizaine en parallèle : quel est le montage qui éclaire le mieux ?&quot;, les élèves répondront souvent que ce sera le montage série : les élèves pensent que le courant ne se séparera pas en deux (ce qui arrive avec les bifurcations dans le montage parallèle), ce qui est faux. Le problème dans ce cas précis, provient de la conception erronée du courant électrique comme un ensemble matériel produit par la pile à débit constant.

Évidemment, il vaut mieux connaître ces idées reçues fréquentes pour prendre les devants. Mais se contenter de corriger ces conceptions erronées ne suffit pas à les faire disparaître. Les conceptions complexes sont extraordinairement résistantes à l'oubli et elles perdurent, même chez les élèves qui ont subi un enseignement correctif élaboré. Pour donner un exemple, je vais citer une expérience faite par Laurence Viennot sur des élèves de terminale S, de DEUG (oui, l’étude date...), et de maîtrise. Elle leur a posé la question suivante : &quot;quand on lance une balle en l'air, quelles forces s’appliquent quand celle-ci monte et descend, frottements mis à part ?&quot;. Près de 55% des élèves de terminale et 33% des étudiants de DEUG pensaient qu'il y avait deux forces, une qui faisait tomber la balle (pesanteur), et une autre qui faisait se mouvoir la balle contre la gravité. Ils utilisaient un modèle de force naïf, qui relie fortement la force à la vitesse. En réalité, il n'y a qu'une seule force : la pesanteur... Pourtant, ces étudiants connaissaient la définition technique d'une force et savaient l'utiliser dans des exercices académiques. Mais dans la situation de l'interrogation, c'était l'idée reçue qui était la plus accessible et qui prenait le dessus.

==Le processus du changement conceptuel==

Les conceptions complexes peuvent cependant se corriger progressivement, par restructuration complète d'un réseau complexe de connaissances fortement interconnectées. Ce processus de correction est appelé le '''changement conceptuel''' par les chercheurs. Et le moins que l'on puisse dire est que ce processus est complexe et mal compris, les théories sur le sujet étant nombreuses. Un point important à comprendre est qu'expliquer le changement conceptuel demande de préciser la nature du réseau de connaissances incluant la conception élaborée. Et à ce petit jeu, deux visions assez opposées s'affrontent.

La première vision considère que ce réseau représente une véritable théorie. Par théorie, on veut dire qu'il forme un ensemble de connaissances cohérent, unifié autour de quelques principes basiques plus ou moins implicites, qui permet d'expliquer un grand nombre de situations, et qui permet de faire des déductions et des prédictions. Évidemment, ces théories ne sont pas aussi élaborées et formalisées que les théories scientifiques. Elles restent assez naïves, sont surtout basées sur des connaissances implicites, font souvent preuve d'une logique pas vraiment formalisée, etc. Mais ces théories naïves sont cependant basées sur une certaine forme de logique et un raisonnement causal. Cette vision, appelée la perspective ''knowledge-as-theory'' par les auteurs anglo-saxons, est opposée au paradigme ''knowledge-as-elements'' qui stipule que les connaissances des élèves ne sont pas aussi bien structurées. Sans forcément n'être qu'un amas de connaissances reliées n'importe comment, cette vision pense que les connaissances ne sont pas organisées de manière cohérente. Un élève peut très bien avoir des connaissances contradictoires sans s'en rendre compte.

Pour bien comprendre la différence, il faut regarder ce que les deux visions prédisent. La première prédiction tient à l'incohérence des constructions mentales. Avec la vision ''knowledge-as-theory'', l'élève ne peut pas avoir de connaissances incohérentes, ou alors seulement à la marge. Après tout, les éléments d'une théorie se contredisent rarement entre eux, ou alors seulement d'une manière qui n'est pas du tout évidente. Si il y a incohérence dans une théorie naïve, elle n'est pas facile à déceler. À l'inverse, la vision ''knowledge-as-elements'' dit qu'il est possible que l'élève ait des connaissances ou des idées franchement incohérentes, sans s'en rendre compte, et qu'il utilise l'une ou l'autre suivant la situation.

Une prédiction liée à cette différence se voit quand un élève doit utiliser ses connaissances pour raisonner, réfléchir, résoudre des problèmes. Le cas à étudier est celui où on soumet l'élève à deux tâches conceptuellement similaires, qui utilisent toutes deux le même ensemble de connaissances et de méthodes. Si l'élève utilise une théorie naïve, il fournira des explications qui sont consistantes, à savoir qu'il n'y aura pas d'explications incohérentes entre les deux tâches. Mais si l'élève n'utilise pas une théorie, mais un réseau mal organisé, le résultat est tout autre. L'élève va alors construire des explications à la volée en utilisant les connaissances qui lui viennent à l'esprit, celles qui sont activées par la tâche demandée. Suivant la tâche, les connaissances activées seront différentes et il n'est pas impossible que l'élève utilise des connaissances incompatibles ou incohérente d'une tâche à l'autre.

Un autre point important est que le changement conceptuel n'a pas lieu de la même manière dans les deux visions. À l'heure actuelle, les chercheurs ne savent pas trop si le changement conceptuel est soudain, le réseau se réorganisant rapidement, ou progressif, par accumulation incrémentale de nouvelles connaissances qui remplacent les anciennes. Les premières théories sur le sujet (les théories de Piaget, notamment) penchaient plutôt du côté d'une réorganisation rapide et soudaine. Mais aujourd'hui, beaucoup de chercheurs pensent que le changement conceptuel peut se faire progressivement, lentement, par construction incrémentale d'un nouveau réseau alternatif du réseau initial. Ce débat est relié à la controverse sur la nature du réseau de connaissances. La première vision, à savoir celle des théories naïves, est plutôt compatible avec un changement brutal. Les théories naïves doivent être réfutées en bloc, avant d'être remplacées par une théorie alternative. La seconde vision, quant à elle, est plutôt compatible avec un changement conceptuel graduel. Les connaissances adéquates sont acquises progressivement, alors que les connaissances inadéquates sont progressivement enfouies dans les tréfonds de la mémoire.

{|class=&quot;wikitable&quot;
|+ Comparaison entre les approches ''knowledge-as-theory'' et ''knowledge-as-elements''
|-
! ''knowledge-as-theory''
! ''knowledge-as-elements''
|-
| colspan=&quot;2&quot; | Les deux visions s’accordent sur les points suivants :
* Les élèves acquièrent des connaissances naïves par induction, notamment lors de leur vie quotidienne.
* Les connaissances naïves influencent l'apprentissage formel, scolaire.
* Les connaissances naïves sont robustes et résistantes au changement.
|-
| Les connaissances naïves sont organisées en théorie cohérentes.
| Les connaissances naïves forment un réseau peu organisé.
|-
| Les connaissances sont appliquées de manière consistante dans des contextes différents pour formuler des explications.
| Les connaissances ne sont pas appliquées de manière consistante dans des contextes différents, mais elles le sont pour un même contexte.
|-
| Les explications sont des déductions de la théorie naïves, formulées à partir de modèles mentaux consistants.
| Les explications sont construites à la volée à partir des connaissances activées par les éléments de la tâche.
|-
| Le changement conceptuel est soudain, basé sur une réorganisation catastrophique des théories naïves.
| Le changement conceptuel est graduel, lent, basé sur une acquisition incrémentale de connaissances.
|}

==Les conceptions ne s'oublient pas et interférent avec l'activité mentale==

Les conceptions simples et élaborées continuent à avoir des conséquences, même une fois qu'elles sont &quot;corrigées&quot; et que l'élève connaît les informations valides. Elles ont tendance à se manifester quand elles ne devraient pas. Évidemment, il faut de la répétition et de l’entraînement pour que la conception disparaisse et que l'élève cesse de faire des erreurs. Mais même après cela, il arrive que la conception ressorte dans des situations peu familières, si l'élève ne fait pas attention, ou dans des cas d'étude un peu particuliers. La raison à cela est que la conception erronée et l'information valide seront toutes deux en mémoire et le deux peuvent être rappelées. Elles vont entrer en compétition pour le rappel et un processus de sélection va choisir quelle est l'information pertinente. Suivant les indices de récupération activés par la tâche, la conception peut ressortir en priorité.

Cela a été plus ou moins montré dans l'étude d’Andrew Shtulman et Joshua, publiée dans le journal cognition. Dans leur étude, 200 cobayes devaient dire si des affirmations étaient vraies ou fausses le plus rapidement possible, les temps de réaction étant mesurés. Parmi ces affirmations, certaines étaient conçues de manière à évoquer des conceptions erronées : &quot;la Lune produit de la lumière&quot;, &quot;1/13 est plus petit qu'1/30&quot;, &quot;les atomes sont principalement composés de vide&quot;, &quot;un kilo de plomb pèse plus qu'un kilo de plumes&quot;, etc. Bilan : les temps de réaction et le taux d'erreur étaient plus élevés pour les affirmations qui évoquaient des conceptions erronées. La raison est que la sélection de l'information valide parmi plusieurs compétiteurs prend un peu de temps, qui se mesure assez bien dans les épreuves de chronométrie mentale.

Cet effet d'interférence est de plus confirmé par quelques rares observations d'imagerie cérébrale. Dans une étude&lt;ref&gt;Étude des mécanismes cérébraux liés à l'expertise scientifique en électricité à l'aide de l'imagerie par résonance magnétique fonctionnelle&lt;/ref&gt;, les chercheurs analysaient le cerveau de deux groupes de cobayes lors de la résolution d'exercices d’électricité : un groupe était constitué de novices, et un autre d'experts en électricité. Ces deux groupes devaient résoudre deux types d'exercices : certains étaient conçus de manière à forcer l'utilisation d'une conception erronée, et les autres non. Cette étude montre que chez le novice, les informations incohérentes avec la conception erronée sont d'abord interprétées par le cerveau comme des erreurs et sont passés sous le tapis : les zones du cerveau chargées de la détection de la surprise s'activent, avant de laisser la place aux zones du cerveau activés lors du désintérêt. En somme, notre esprit n'aime pas remettre en cause ce qu'il sait déjà. Par contre, les zones du cerveau qui s'activaient chez les experts étaient celles dévolues à l''''inhibition''', à savoir la capacité à empêcher le rappel d'une connaissance depuis la mémoire à long terme. En clair, la conception erronée était encore présente dans le cerveau, mais le cerveau se chargeait d’en empêcher le rappel et l'utilisation.

==Les implications pédagogiques : provoquer le changement conceptuel==

Première recommandation : '''il faut éviter l'apparition de conceptions erronées''', et faire en sorte que les connaissances des élèves soient d'emblée les plus fiables possibles. Toute connaissance apprise à un niveau donné d'étude doit être conçue pour ne pas interférer avec des apprentissages ultérieurs. Les simplifications outrancières dans les premières années d'études sont en effet très préjudiciables pour la progression future. Les pédagogies actives sont aussi une catastrophe de ce point de vue : les élèves procèdent par séries d'essais et d'erreurs, il existe un risque que les erreurs soient mémorisées avec la connaissance correcte. La progression devient très lente si les élèves assimilent des connaissances boiteuses et des erreurs de compréhension.

Seconde recommandation : '''il ne faut pas laisser l'erreur s'installer'''. Les conceptions erronées que forme l'élève au cours de son apprentissage doivent être corrigées au plus vite, avant d'être inscrites dans la mémoire à long terme. Pour cela, le professeur doit réserver sur chaque cours une période de feedback, qui permet aux élèves d'identifier leurs erreurs de compréhension et de les corriger. Dans cette phase, le professeur va tester les élèves avec des questions de compréhension, voire par une série d'interrogations écrites. La solution privilégiée est l'utilisation massive d'interrogation écrites fréquentes.

Une autre recommandation tient dans la formulation des explications, de la correction. Quand on veut remplacer une conception par une information valide, il faut que cette dernière soit présentée d'une certaine manière pour être vraiment efficace. Déjà, il faut que l'élève soit en quelque sorte préparé à remettre en cause la conception. Il doit sentir que quelque chose ne va pas avoir la conception, qu'elle est incompatible avec certaines connaissances tenues pour certaines, certains résultats expérimentaux fiables, qu'elle mène à des incohérences. Il ne suffit pas de présenter une explication alternative, il faut que celle-ci soit justifiée et serve vraiment à répondre à des objections auxquelles la conception ne peut répondre. Présenter une explication alternative seule risque de na pas passer très bien si l'élève pense que la conception donne le même résultat. Ensuite, il faut que l'explication soit simple, claire, facile à mémoriser et à comprendre. Une explication incompréhensible ne donnera évidemment pas de bons résultats. Et il faut aussi qu'elle soit plausible. Par plausible, on veut dire qu'elle doit être intuitive (idéalement), mais aussi qu'elle doit répondre aux objections formulées envers la conception.

==Références==

&lt;references/&gt;

&lt;noinclude&gt;
{{NavChapitre | book=Psychologie cognitive pour l'enseignant
           | prev=Développer sa méta-cognition
           | prevText=Développer sa méta-cognition
           | next=Transfert d'apprentissages
           | nextText=Le transfert d'apprentissages
}}{{autoCat}}
&lt;/noinclude&gt;</text>
      <sha1>lron8fi7a24lp9sfass8usgog7xn9jm</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Assembleur/x86/Copie entre registres et mémoire</title>
    <ns>0</ns>
    <id>59004</id>
    <revision>
      <id>684320</id>
      <parentid>671116</parentid>
      <timestamp>2022-08-28T10:06:55Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>/* Répétition et boucle */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12174" xml:space="preserve">{{Programmation assembleur x86}}

== Syntaxes des assembleurs ==

Il existe deux variantes principales et opposées de syntaxe pour les instructions en assembleur :
* la syntaxe Intel où l'opérande destination est placé avant l'opérande source.
:Exemple : &lt;syntaxhighlight lang=&quot;nasm&quot; inline&gt;mov ax, bx  ; AX &lt;- BX  transfert des 16 bits de BX vers AX.&lt;/syntaxhighlight&gt;
* la syntaxe AT&amp;T où l'opérande source est placé avant l'opérande destination.
:Exemple : &lt;syntaxhighlight lang=&quot;asm&quot; inline&gt;mov %bx, %ax  ; BX -&gt; AX  transfert des 16 bits de BX vers AX.&lt;/syntaxhighlight&gt;

L'interprétation peut donc est ambiguë si on ne sait pas quelle syntaxe est employée.
Les assembleurs sous DOS et Windows utilisent la syntaxe Intel, qui semble plus naturelle pour les opérations arithmétiques et conserve l'ordre des expressions arithmétiques :
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
add eax, 7  ; EAX &lt;- EAX+7
&lt;/syntaxhighlight&gt;

Les assembleurs sous Linux utilisent la syntaxe AT&amp;T, qui conserve l'ordre des mots pour expliquer les expressions arithmétiques :
&lt;syntaxhighlight lang=&quot;asm&quot;&gt;
add $7, %eax  ; Ajouter 7 à EAX
&lt;/syntaxhighlight&gt;

La distinction entre les deux syntaxes est donc importante à faire :
* Dans la syntaxe Intel où l'opérande destination est placé avant l'opérande source, le nom des registres et les valeurs littérales n'ont pas de préfixe.
* Dans la syntaxe AT&amp;T où l'opérande source est placé avant l'opérande destination, le nom des registres est préfixé par le caractère pourcent et les valeurs littérales sont préfixé par le caractère dollar.

{| class=&quot;wikitable&quot;
! syntaxe Intel (DOS, Windows, ...)
! syntaxe AT&amp;T (Linux, ...)
|-
|
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
add eax, 7
mov dword ptr [rbp-0x4],edi
imul ecx, [rdi + rax*4 + 20], 12345
&lt;/syntaxhighlight&gt;
|
&lt;syntaxhighlight lang=&quot;asm&quot;&gt;
add $7, %eax
mov %edi,-0x4(%rbp)
imul $12345, 20(%rdi, %rax, 4), %ecx
&lt;/syntaxhighlight&gt;
|}

== Transfert unitaire ==

L'instruction la plus courante est MOV (abréviation de l'anglais ''move'' : déplacer) qui permet de transférer le contenu d'un emplacement mémoire vers un registre et inversement, ou entre deux registres de même taille.

Le nombre de bits transféré est défini par la taille du registre source ou cible du transfert.
Exemple (syntaxe destination, source) :
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
mov ax, bx  ; transfert des 16 bits de BX vers AX.
&lt;/syntaxhighlight&gt;

Les assembleurs peuvent employer des suffixes pour le nom de l'instruction indiquant ce nombre d'octets :
* movb (''Move Byte'') : 8 bits,
* movw (''Move Word'') : 16 bits,
* movl (''Move Long'') : 32 bits.

Exemple (syntaxe source, destination) :
&lt;syntaxhighlight lang=&quot;asm&quot;&gt;
.data

valeur:
        .long   2

.text
        .global _start

_start:
        movl    $6, %eax
        # %eax = 6

        movw    %ax, valeur
        # valeur = 6

        movl    $0, %ebx
        # %ebx = 0

        movb    %al, %bl
        # %ebx = 6

        movl    valeur, %ebx
        # %ebx = 6

        movl    $valeur, %esi
        # %esi = l’address de valeur

        xorl    %ebx, %ebx
        # %ebx = 0

        movw    valeur(, %ebx, 1), %bx
        # %ebx = 6

# Linux sys_exit
        mov     $1, %eax
        xorl    %ebx, %ebx
        int     $0x80
&lt;/syntaxhighlight&gt;

== Transfert de séquence ==

Une famille d'instructions gère les séquences d'octets en mémoire :
* les instructions &lt;code&gt;MOVS&lt;/code&gt; transfèrent les octets d'une zone mémoire à une autre ('''''Mov'''e '''S'''equence''),
* les instructions &lt;code&gt;CMPS&lt;/code&gt; comparent le contenu de deux zones mémoire ('''''C'''o'''mp'''are '''S'''equence''),
* les instructions &lt;code&gt;LODS&lt;/code&gt; transfère les octets d'une zone mémoire vers le registre EAX ('''''Lo'''a'''d''' '''S'''equence''),
* les instructions &lt;code&gt;STOS&lt;/code&gt; transfère le contenu du registre EAX vers une zone mémoire ('''''Sto'''re '''S'''equence''),
* les instructions &lt;code&gt;SCAS&lt;/code&gt; comparent le contenu du registre EAX à celui d'une zone mémoire ('''''Sca'''n '''S'''equence'').

=== Quantité traitée ===
Le nom de ces opérations se termine par un préfixe indiquant la quantité traitée à chaque appel :
* &lt;code&gt;B&lt;/code&gt; ('''''B'''yte'') pour un octet de 8 bits : &lt;code&gt;MOVSB&lt;/code&gt;, &lt;code&gt;CMPSB&lt;/code&gt;, &lt;code&gt;LODSB&lt;/code&gt;, &lt;code&gt;STOSB&lt;/code&gt;, &lt;code&gt;SCASB&lt;/code&gt; ;
* &lt;code&gt;W&lt;/code&gt; ('''''W'''ord'') pour un mot de 16 bits : &lt;code&gt;MOVSW&lt;/code&gt;, &lt;code&gt;CMPSW&lt;/code&gt;, &lt;code&gt;LODSW&lt;/code&gt;, &lt;code&gt;STOSW&lt;/code&gt;, &lt;code&gt;SCASW&lt;/code&gt; ;
* &lt;code&gt;D&lt;/code&gt; ('''''D'''ouble word'') pour un double mot (32 bits) : &lt;code&gt;MOVSD&lt;/code&gt;, &lt;code&gt;CMPSD&lt;/code&gt;, &lt;code&gt;LODSD&lt;/code&gt;, &lt;code&gt;STOSD&lt;/code&gt;, &lt;code&gt;SCASD&lt;/code&gt;.

=== Registres utilisés et opérations ===
Ces opérations utilisent les registres dédiés pour adresser la mémoire :
* '''DS:SI''' / '''DS:ESI''' pointant la zone mémoire source (instructions &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;CMPS*&lt;/code&gt;, &lt;code&gt;LODS*&lt;/code&gt;),
* '''ES:DI''' / '''ES:EDI''' pointant la zone mémoire destination (instructions &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;CMPS*&lt;/code&gt;, &lt;code&gt;STOS*&lt;/code&gt;, &lt;code&gt;SCAS*&lt;/code&gt;).

Ces registres sont incrémentés ou décrémentés après chaque traitement par ces opérations, selon la valeur de [[../Les flags#Direction Flag (DF)|l'indicateur de direction (DF)]] :
* s'il est positionné à 0, les registres '''(E)SI''' et '''(E)DI''' sont incrémentés de 1, 2 ou 4 selon la quantité traitée à chaque appel,
* S'il est positionné à 1, les registres '''(E)SI''' et '''(E)DI''' sont décrémentés de 1, 2 ou 4 selon la quantité traitée à chaque appel.
Mnémotechnique : ''DF = Decrement Flag''

Cet indicateur est généralement positionné juste avant les instructions de traitement en utilisant l'instruction &lt;code&gt;CLD&lt;/code&gt; ('''''CL'''ear '''D'''irection'') ou &lt;code&gt;STD&lt;/code&gt; ('''''S'''e'''T''' '''D'''irection'').

Le tableau ci-dessous résume les opérations effectuées par les instructions et les registres utilisés :

{| class=&quot;wikitable&quot;
! Instructions
! Source
! Destination
! Opération
|-
| MOVS*
| '''[DS:(E)SI]'''
| '''[ES:(E)DI]'''
| Transfert de source vers destination (Move).
|-
| LODS*
| '''[DS:(E)SI]'''
| '''(E)AX'''
| Transfert de source vers le registre EAX (Load).
|-
| STOS*
| '''(E)AX'''
| '''[ES:(E)DI]'''
| Transfert du registre EAX vers destination (Store).
|-
| CMPS*
| '''[DS:(E)SI]'''
| '''[ES:(E)DI]'''
| Met à jour [[../Les flags|les indicateurs]] après comparaison entre source et destination.
|-
| SCAS*
| '''(E)AX'''
| '''[ES:(E)DI]'''
| Met à jour [[../Les flags|les indicateurs]] après comparaison entre le registre EAX et destination.
|}

=== Répétition et boucle ===
Ces instructions effectuent le traitement d'une quantité unitaire de données, mais deviennent efficaces et puissantes en combinaison d'instructions répétant l'opération en boucle.
Pour répéter ces opérations, les instructions de boucle et répétition utilisent le registre CX ('''C'''ounter) en le décrémentant et répétant l'opération tant que le compteur n'atteint pas zéro.
Le registre CX est donc initialisé avant la boucle ou répétition avec le nombre d'octets, de mots ou de double-mots à traiter.

&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Code non montré :
; ... initialiser les registres DS, SI pour la source
; ... initialiser les registres ES, DI pour la destination,
mov cx, 0x1FF   ; transférer 511 mots de 16 bits
cld             ; incrémenter les pointeurs après chaque itération
rep             ; répéter CX fois...
movsw           ; ...le transfert d'un mot de 16 bits
&lt;/syntaxhighlight&gt;

* L'instruction &lt;code&gt;REPZ&lt;/code&gt; répète l'instruction de séquence qui suit tant que le registre CX n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag Zero (ZF)]] vaut 0 (c'est à dire jusqu'à ZF=1 : '''''REP'''eat until '''Z'''ero'').
* L'instruction &lt;code&gt;REPNZ&lt;/code&gt; répète l'instruction de séquence qui suit tant que le registre CX n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag Zero (ZF)]] vaut 1 (c'est à dire jusqu'à ZF=0 : '''''REP'''eat until '''N'''ot '''Z'''ero'').

Le [[../Les flags#Zero Flag (ZF)|flag Zero (ZF)]] est pris en compte seulement si l'opération qui suit est &lt;code&gt;CMPS*&lt;/code&gt; ou &lt;code&gt;SCAS*&lt;/code&gt;.

Il est ignoré pour les opérations de transfert &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;LODS*&lt;/code&gt; ou &lt;code&gt;STOS*&lt;/code&gt;.
Cela signifie que pour ces 3 opérations &lt;code&gt;REPZ&lt;/code&gt; et &lt;code&gt;REPNZ&lt;/code&gt; sont identiques, et les assembleurs ajoutent donc un alias &lt;code&gt;REP&lt;/code&gt; qui en général est compilé en une instruction &lt;code&gt;REPZ&lt;/code&gt;.

Les préfixes &lt;code&gt;REPZ&lt;/code&gt; et &lt;code&gt;REPNZ&lt;/code&gt; ne répète que l'instruction de séquence qui suit.
Pour répéter une série d'instructions, notamment pour &lt;code&gt;LODS*&lt;/code&gt; où l'assignation répétée dans le registre AX n'a pas d'intérêt réel, il faut utiliser les instructions &lt;code&gt;LOOP*&lt;/code&gt;.

Les instructions &lt;code&gt;LOOP*&lt;/code&gt; ont 3 variantes dont le comportement ne varient que par rapport [[../Les flags#Zero Flag (ZF)|au flag zéro (ZF)]] :
* L'instruction &lt;code&gt;LOOPZ&lt;/code&gt; décrémente le registre (E)CX, puis s'il n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag zéro (ZF)]] vaut 1 ('''''LOOP''' while CX &gt; 0 and '''Z'''ero'') saute à l'adresse indiquée.
* L'instruction &lt;code&gt;LOOPNZ&lt;/code&gt; décrémente le registre (E)CX, puis s'il n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag zéro (ZF)]] vaut 0 ('''''LOOP''' while CX &gt; 0 and '''N'''ot '''Z'''ero'') saute à l'adresse indiquée.
* L'instruction &lt;code&gt;LOOP&lt;/code&gt; décrémente le registre (E)CX, puis s'il n'est pas à zéro ('''''LOOP''' while CX &gt; 0) saute à l'adresse indiquée.

&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Code non montré :
; ... initialiser les registres DS, SI pour la source
  mov cx, 200     ; lire 200 octets
  cld             ; incrémenter les pointeurs après chaque itération
:iteration
  lodsb            ; lecture d'un octet de DS:(E)SI dans AL
  call printchar   ; appel à une sous-routine pour afficher le caractère de code AL
  cmp al, 0        ; compare AL à 00 qui marque la fin de chaîne de caractère
  loopnz iteration ; décrémente CX, et boucle si ZF=0 (AL différent de 00)
&lt;/syntaxhighlight&gt;

Enfin, il existe une [[../Les branchements#Saut conditionnel|instruction &lt;code&gt;JCXZ&lt;/code&gt;]] qui ne modifie pas le registre (E)CX mais saute à l'adresse indiquée si le registre (E)CX vaut 0.
Dans le cas d'un compteur d'itération, elle permet donc de sortir d'une boucle infinie.

=== Préfixes de changement de segment ===
Les préfixes de changement de segment n'influence que le registre de segment DS utilisé pour la source.
Cela signifie qu'ils n'influencent que les instructions &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;CMPS*&lt;/code&gt;, &lt;code&gt;LODS*&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Code non montré :
; ... initialiser les registres ES, SI pour la source (même registre ES que la destination)
; ... initialiser les registres ES, DI pour la destination,
mov cx, 0x1FF   ; transférer 511 mots de 16 bits
cld             ; incrémenter les pointeurs après chaque itération
es:             ; utiliser le segment ES au lieu de DS
rep             ; répéter CX fois...
movsw           ; ...le transfert d'un mot de 16 bits
&lt;/syntaxhighlight&gt;

== Autres transferts ==

Le transfert entre certains registres pour lesquels il n'existe pas d'instruction peut s'effectuer en utilisant [[../La pile|la pile]], comme par exemple pour le transfert entre le registre AX et celui des indicateurs (FLAGS) :
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Transfert de FLAGS vers AX
pushf      ; met la valeur du registre FLAGS dans le pile,
pop ax     ; puis la retire de la pile pour la mettre dans le registre AX.
&lt;/syntaxhighlight&gt;

L'instruction &lt;code&gt;LAHF&lt;/code&gt; ('''''L'''oad '''AH''' from '''F'''lags'') permet de transférer la valeur des 8 bits de poids faible du registre FLAGS vers le registre AH (bits 15 à 8 du registre AX / EAX).
L'instruction &lt;code&gt;SAHF&lt;/code&gt; ('''''S'''ave '''AH''' to '''F'''lags'') effectue le transfert inverse.

L'instruction &lt;code&gt;XLAT&lt;/code&gt; transfère l'octet pointé par DS:(BX+AL) dans le registre AL.

[[en:X86 Assembly/Data Transfer]]</text>
      <sha1>7q83rnz7bcfgph2gvkcd8fcszt2wivy</sha1>
    </revision>
    <revision>
      <id>684321</id>
      <parentid>684320</parentid>
      <timestamp>2022-08-28T11:38:39Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>/* Syntaxes des assembleurs */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12176" xml:space="preserve">{{Programmation assembleur x86}}

== Syntaxes des assembleurs ==

Il existe deux variantes principales et opposées de syntaxe pour les instructions en assembleur :
* la syntaxe Intel où l'opérande destination est placé avant l'opérande source.
:Exemple : &lt;syntaxhighlight lang=&quot;nasm&quot; inline&gt;mov ax, bx  ; AX &lt;- BX  transfert des 16 bits de BX vers AX.&lt;/syntaxhighlight&gt;
* la syntaxe AT&amp;T où l'opérande source est placé avant l'opérande destination.
:Exemple : &lt;syntaxhighlight lang=&quot;asm&quot; inline&gt;mov %bx, %ax  ; BX -&gt; AX  transfert des 16 bits de BX vers AX.&lt;/syntaxhighlight&gt;

L'interprétation peut donc être ambiguë si on ne sait pas quelle syntaxe est employée.
Les assembleurs sous DOS et Windows utilisent la syntaxe Intel, qui semble plus naturelle pour les opérations arithmétiques et conserve l'ordre des expressions arithmétiques :
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
add eax, 7  ; EAX &lt;- EAX+7
&lt;/syntaxhighlight&gt;

Les assembleurs sous Linux utilisent la syntaxe AT&amp;T, qui conserve l'ordre des mots pour expliquer les expressions arithmétiques :
&lt;syntaxhighlight lang=&quot;asm&quot;&gt;
add $7, %eax  ; Ajouter 7 à EAX
&lt;/syntaxhighlight&gt;

La distinction entre les deux syntaxes est donc importante à faire :
* Dans la syntaxe Intel où l'opérande destination est placé avant l'opérande source, le nom des registres et les valeurs littérales n'ont pas de préfixe.
* Dans la syntaxe AT&amp;T où l'opérande source est placé avant l'opérande destination, le nom des registres est préfixé par le caractère pourcent et les valeurs littérales sont préfixé par le caractère dollar.

{| class=&quot;wikitable&quot;
! syntaxe Intel (DOS, Windows, ...)
! syntaxe AT&amp;T (Linux, ...)
|-
|
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
add eax, 7
mov dword ptr [rbp-0x4],edi
imul ecx, [rdi + rax*4 + 20], 12345
&lt;/syntaxhighlight&gt;
|
&lt;syntaxhighlight lang=&quot;asm&quot;&gt;
add $7, %eax
mov %edi,-0x4(%rbp)
imul $12345, 20(%rdi, %rax, 4), %ecx
&lt;/syntaxhighlight&gt;
|}

== Transfert unitaire ==

L'instruction la plus courante est MOV (abréviation de l'anglais ''move'' : déplacer) qui permet de transférer le contenu d'un emplacement mémoire vers un registre et inversement, ou entre deux registres de même taille.

Le nombre de bits transféré est défini par la taille du registre source ou cible du transfert.
Exemple (syntaxe destination, source) :
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
mov ax, bx  ; transfert des 16 bits de BX vers AX.
&lt;/syntaxhighlight&gt;

Les assembleurs peuvent employer des suffixes pour le nom de l'instruction indiquant ce nombre d'octets :
* movb (''Move Byte'') : 8 bits,
* movw (''Move Word'') : 16 bits,
* movl (''Move Long'') : 32 bits.

Exemple (syntaxe source, destination) :
&lt;syntaxhighlight lang=&quot;asm&quot;&gt;
.data

valeur:
        .long   2

.text
        .global _start

_start:
        movl    $6, %eax
        # %eax = 6

        movw    %ax, valeur
        # valeur = 6

        movl    $0, %ebx
        # %ebx = 0

        movb    %al, %bl
        # %ebx = 6

        movl    valeur, %ebx
        # %ebx = 6

        movl    $valeur, %esi
        # %esi = l’address de valeur

        xorl    %ebx, %ebx
        # %ebx = 0

        movw    valeur(, %ebx, 1), %bx
        # %ebx = 6

# Linux sys_exit
        mov     $1, %eax
        xorl    %ebx, %ebx
        int     $0x80
&lt;/syntaxhighlight&gt;

== Transfert de séquence ==

Une famille d'instructions gère les séquences d'octets en mémoire :
* les instructions &lt;code&gt;MOVS&lt;/code&gt; transfèrent les octets d'une zone mémoire à une autre ('''''Mov'''e '''S'''equence''),
* les instructions &lt;code&gt;CMPS&lt;/code&gt; comparent le contenu de deux zones mémoire ('''''C'''o'''mp'''are '''S'''equence''),
* les instructions &lt;code&gt;LODS&lt;/code&gt; transfère les octets d'une zone mémoire vers le registre EAX ('''''Lo'''a'''d''' '''S'''equence''),
* les instructions &lt;code&gt;STOS&lt;/code&gt; transfère le contenu du registre EAX vers une zone mémoire ('''''Sto'''re '''S'''equence''),
* les instructions &lt;code&gt;SCAS&lt;/code&gt; comparent le contenu du registre EAX à celui d'une zone mémoire ('''''Sca'''n '''S'''equence'').

=== Quantité traitée ===
Le nom de ces opérations se termine par un préfixe indiquant la quantité traitée à chaque appel :
* &lt;code&gt;B&lt;/code&gt; ('''''B'''yte'') pour un octet de 8 bits : &lt;code&gt;MOVSB&lt;/code&gt;, &lt;code&gt;CMPSB&lt;/code&gt;, &lt;code&gt;LODSB&lt;/code&gt;, &lt;code&gt;STOSB&lt;/code&gt;, &lt;code&gt;SCASB&lt;/code&gt; ;
* &lt;code&gt;W&lt;/code&gt; ('''''W'''ord'') pour un mot de 16 bits : &lt;code&gt;MOVSW&lt;/code&gt;, &lt;code&gt;CMPSW&lt;/code&gt;, &lt;code&gt;LODSW&lt;/code&gt;, &lt;code&gt;STOSW&lt;/code&gt;, &lt;code&gt;SCASW&lt;/code&gt; ;
* &lt;code&gt;D&lt;/code&gt; ('''''D'''ouble word'') pour un double mot (32 bits) : &lt;code&gt;MOVSD&lt;/code&gt;, &lt;code&gt;CMPSD&lt;/code&gt;, &lt;code&gt;LODSD&lt;/code&gt;, &lt;code&gt;STOSD&lt;/code&gt;, &lt;code&gt;SCASD&lt;/code&gt;.

=== Registres utilisés et opérations ===
Ces opérations utilisent les registres dédiés pour adresser la mémoire :
* '''DS:SI''' / '''DS:ESI''' pointant la zone mémoire source (instructions &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;CMPS*&lt;/code&gt;, &lt;code&gt;LODS*&lt;/code&gt;),
* '''ES:DI''' / '''ES:EDI''' pointant la zone mémoire destination (instructions &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;CMPS*&lt;/code&gt;, &lt;code&gt;STOS*&lt;/code&gt;, &lt;code&gt;SCAS*&lt;/code&gt;).

Ces registres sont incrémentés ou décrémentés après chaque traitement par ces opérations, selon la valeur de [[../Les flags#Direction Flag (DF)|l'indicateur de direction (DF)]] :
* s'il est positionné à 0, les registres '''(E)SI''' et '''(E)DI''' sont incrémentés de 1, 2 ou 4 selon la quantité traitée à chaque appel,
* S'il est positionné à 1, les registres '''(E)SI''' et '''(E)DI''' sont décrémentés de 1, 2 ou 4 selon la quantité traitée à chaque appel.
Mnémotechnique : ''DF = Decrement Flag''

Cet indicateur est généralement positionné juste avant les instructions de traitement en utilisant l'instruction &lt;code&gt;CLD&lt;/code&gt; ('''''CL'''ear '''D'''irection'') ou &lt;code&gt;STD&lt;/code&gt; ('''''S'''e'''T''' '''D'''irection'').

Le tableau ci-dessous résume les opérations effectuées par les instructions et les registres utilisés :

{| class=&quot;wikitable&quot;
! Instructions
! Source
! Destination
! Opération
|-
| MOVS*
| '''[DS:(E)SI]'''
| '''[ES:(E)DI]'''
| Transfert de source vers destination (Move).
|-
| LODS*
| '''[DS:(E)SI]'''
| '''(E)AX'''
| Transfert de source vers le registre EAX (Load).
|-
| STOS*
| '''(E)AX'''
| '''[ES:(E)DI]'''
| Transfert du registre EAX vers destination (Store).
|-
| CMPS*
| '''[DS:(E)SI]'''
| '''[ES:(E)DI]'''
| Met à jour [[../Les flags|les indicateurs]] après comparaison entre source et destination.
|-
| SCAS*
| '''(E)AX'''
| '''[ES:(E)DI]'''
| Met à jour [[../Les flags|les indicateurs]] après comparaison entre le registre EAX et destination.
|}

=== Répétition et boucle ===
Ces instructions effectuent le traitement d'une quantité unitaire de données, mais deviennent efficaces et puissantes en combinaison d'instructions répétant l'opération en boucle.
Pour répéter ces opérations, les instructions de boucle et répétition utilisent le registre CX ('''C'''ounter) en le décrémentant et répétant l'opération tant que le compteur n'atteint pas zéro.
Le registre CX est donc initialisé avant la boucle ou répétition avec le nombre d'octets, de mots ou de double-mots à traiter.

&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Code non montré :
; ... initialiser les registres DS, SI pour la source
; ... initialiser les registres ES, DI pour la destination,
mov cx, 0x1FF   ; transférer 511 mots de 16 bits
cld             ; incrémenter les pointeurs après chaque itération
rep             ; répéter CX fois...
movsw           ; ...le transfert d'un mot de 16 bits
&lt;/syntaxhighlight&gt;

* L'instruction &lt;code&gt;REPZ&lt;/code&gt; répète l'instruction de séquence qui suit tant que le registre CX n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag Zero (ZF)]] vaut 0 (c'est à dire jusqu'à ZF=1 : '''''REP'''eat until '''Z'''ero'').
* L'instruction &lt;code&gt;REPNZ&lt;/code&gt; répète l'instruction de séquence qui suit tant que le registre CX n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag Zero (ZF)]] vaut 1 (c'est à dire jusqu'à ZF=0 : '''''REP'''eat until '''N'''ot '''Z'''ero'').

Le [[../Les flags#Zero Flag (ZF)|flag Zero (ZF)]] est pris en compte seulement si l'opération qui suit est &lt;code&gt;CMPS*&lt;/code&gt; ou &lt;code&gt;SCAS*&lt;/code&gt;.

Il est ignoré pour les opérations de transfert &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;LODS*&lt;/code&gt; ou &lt;code&gt;STOS*&lt;/code&gt;.
Cela signifie que pour ces 3 opérations &lt;code&gt;REPZ&lt;/code&gt; et &lt;code&gt;REPNZ&lt;/code&gt; sont identiques, et les assembleurs ajoutent donc un alias &lt;code&gt;REP&lt;/code&gt; qui en général est compilé en une instruction &lt;code&gt;REPZ&lt;/code&gt;.

Les préfixes &lt;code&gt;REPZ&lt;/code&gt; et &lt;code&gt;REPNZ&lt;/code&gt; ne répète que l'instruction de séquence qui suit.
Pour répéter une série d'instructions, notamment pour &lt;code&gt;LODS*&lt;/code&gt; où l'assignation répétée dans le registre AX n'a pas d'intérêt réel, il faut utiliser les instructions &lt;code&gt;LOOP*&lt;/code&gt;.

Les instructions &lt;code&gt;LOOP*&lt;/code&gt; ont 3 variantes dont le comportement ne varient que par rapport [[../Les flags#Zero Flag (ZF)|au flag zéro (ZF)]] :
* L'instruction &lt;code&gt;LOOPZ&lt;/code&gt; décrémente le registre (E)CX, puis s'il n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag zéro (ZF)]] vaut 1 ('''''LOOP''' while CX &gt; 0 and '''Z'''ero'') saute à l'adresse indiquée.
* L'instruction &lt;code&gt;LOOPNZ&lt;/code&gt; décrémente le registre (E)CX, puis s'il n'est pas à zéro et que [[../Les flags#Zero Flag (ZF)|le flag zéro (ZF)]] vaut 0 ('''''LOOP''' while CX &gt; 0 and '''N'''ot '''Z'''ero'') saute à l'adresse indiquée.
* L'instruction &lt;code&gt;LOOP&lt;/code&gt; décrémente le registre (E)CX, puis s'il n'est pas à zéro ('''''LOOP''' while CX &gt; 0) saute à l'adresse indiquée.

&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Code non montré :
; ... initialiser les registres DS, SI pour la source
  mov cx, 200     ; lire 200 octets
  cld             ; incrémenter les pointeurs après chaque itération
:iteration
  lodsb            ; lecture d'un octet de DS:(E)SI dans AL
  call printchar   ; appel à une sous-routine pour afficher le caractère de code AL
  cmp al, 0        ; compare AL à 00 qui marque la fin de chaîne de caractère
  loopnz iteration ; décrémente CX, et boucle si ZF=0 (AL différent de 00)
&lt;/syntaxhighlight&gt;

Enfin, il existe une [[../Les branchements#Saut conditionnel|instruction &lt;code&gt;JCXZ&lt;/code&gt;]] qui ne modifie pas le registre (E)CX mais saute à l'adresse indiquée si le registre (E)CX vaut 0.
Dans le cas d'un compteur d'itération, elle permet donc de sortir d'une boucle infinie.

=== Préfixes de changement de segment ===
Les préfixes de changement de segment n'influence que le registre de segment DS utilisé pour la source.
Cela signifie qu'ils n'influencent que les instructions &lt;code&gt;MOVS*&lt;/code&gt;, &lt;code&gt;CMPS*&lt;/code&gt;, &lt;code&gt;LODS*&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Code non montré :
; ... initialiser les registres ES, SI pour la source (même registre ES que la destination)
; ... initialiser les registres ES, DI pour la destination,
mov cx, 0x1FF   ; transférer 511 mots de 16 bits
cld             ; incrémenter les pointeurs après chaque itération
es:             ; utiliser le segment ES au lieu de DS
rep             ; répéter CX fois...
movsw           ; ...le transfert d'un mot de 16 bits
&lt;/syntaxhighlight&gt;

== Autres transferts ==

Le transfert entre certains registres pour lesquels il n'existe pas d'instruction peut s'effectuer en utilisant [[../La pile|la pile]], comme par exemple pour le transfert entre le registre AX et celui des indicateurs (FLAGS) :
&lt;syntaxhighlight lang=&quot;nasm&quot;&gt;
; Transfert de FLAGS vers AX
pushf      ; met la valeur du registre FLAGS dans le pile,
pop ax     ; puis la retire de la pile pour la mettre dans le registre AX.
&lt;/syntaxhighlight&gt;

L'instruction &lt;code&gt;LAHF&lt;/code&gt; ('''''L'''oad '''AH''' from '''F'''lags'') permet de transférer la valeur des 8 bits de poids faible du registre FLAGS vers le registre AH (bits 15 à 8 du registre AX / EAX).
L'instruction &lt;code&gt;SAHF&lt;/code&gt; ('''''S'''ave '''AH''' to '''F'''lags'') effectue le transfert inverse.

L'instruction &lt;code&gt;XLAT&lt;/code&gt; transfère l'octet pointé par DS:(BX+AL) dans le registre AL.

[[en:X86 Assembly/Data Transfer]]</text>
      <sha1>7dfgekk6v0px7ya7q135j9d4qnrsn7w</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Fabricants/Mélico</title>
    <ns>0</ns>
    <id>59849</id>
    <revision>
      <id>684313</id>
      <parentid>455826</parentid>
      <timestamp>2022-08-27T18:51:36Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="230" xml:space="preserve">{{Ph s Fabricants}}


'''Mélico''' était un fabricant de matériel pour la photographie.

* Analyseur couleur Mark III (environ 1 700 F en 1979.

* Analyseur couleurs pour le laboratoire PM-4 (1979, 4 000 F).


{{Ph Fabricants}}</text>
      <sha1>ou2ubshz7vyjh7teha6wx0fz2tj9zjf</sha1>
    </revision>
  </page>
  <page>
    <title>Recettes de villages qui bougent/Maine-et-Loire/Taillis aux épices</title>
    <ns>0</ns>
    <id>60389</id>
    <revision>
      <id>684300</id>
      <parentid>517176</parentid>
      <timestamp>2022-08-27T18:34:25Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2288" xml:space="preserve">{{livre de cuisine}}
== La recette ==
=== Ingrédients ===
* 120 g d'{{i|amande|'=o}}s douces non pelées
* 150 g de mie de {{i|pain}}
* 150 g de petits {{i|raisin}}s de Corinthe
* 2 jolies {{i|pomme}}s de verger que vous couperez en petits dés
* 4 cuillerées de {{i|miel}} d'acacia, une pincée de {{i|cannelle}}, une pointe de {{i|gingembre}} et une pincée de {{i|safran}}

=== Matériel ===
La cuisson se fait en casserole.

=== Préparation ===
La veille, préparez votre lait d'amandes et faites macérer vos raisins.
Faites tremper vos amandes entières dans un peu d'eau de source et mettez vos petits raisins dans une coupe avec une larme d'eau de vie.

Pour préparer votre recette, il vous faudra monter vos amandes (pour cela Hermine les jette tout simplement dans de l'eau bouillante, les égoutte et les passe sous l'eau froide, la peau brune s'en va ainsi d'une simple pression du doigt). Prenez les amandes épluchées et mixez-les avec 1 litre d'eau de source.

Faites chauffer en casserole de cuivre à feu doux et jusqu'à épaississement, votre lait ainsi que la mie de pain le miel et les pommes coupées en petits dés. Mettez ensuite vos raisins, la cannelle, le gingembre et le safran pour obtenir une belle couleur jaune d'or.
 
Versez ensuite cette pâte odorante dans un moule à cake sur du papier sulfurisé. Laissez refroidir pendant plusieurs heures. N'hésitez pas à mettre votre taillis au réfrigérateur, il prendra plus aisément.

=== Astuce, variantes ===
Ce taillis aux épices se sert frais, posé sur un tranchoir. On y taille des tranches (d'où son nom). Il est très agréable avec des boissons chaudes ou un petit verre d'hypocras.

== Le territoire ==
Ce dessert, le favori d'Hermine, est frais et léger.

''Commenter ici le rapport de la recette au patrimoine local : le contexte historique, social, économique : est-ce une recette traditionnelle ? sont-ce les produits utilisés qui sont liés au territoire ? est-elle liée à une coutume, à une fête, à une personnalité ? etc.''

== L'acteur ==
''Décrire ici le contexte qui a donné lieu à la collecte de la recette. Par qui ? Pour quoi ? Est-ce pendant une fête ou en la préparant, à l'occasion d'un travail de collectage, lors d'un cours de cuisine, etc. ?''

{{AutoCat}}</text>
      <sha1>l5ntyugl4s6ulcmdfqwix9gsui4eifz</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/B/Jack Boucher</title>
    <ns>0</ns>
    <id>63391</id>
    <revision>
      <id>684268</id>
      <parentid>566638</parentid>
      <timestamp>2022-08-27T18:11:36Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16866" xml:space="preserve">{{Ph s Personnalités}}


'''Jack E. Boucher''' était un photographe états-unien né le 4 septembre 1931 à Buffalo, New-York, et décédé à Silver Spring, Maryland, le 2 septembre 2012. Il a travaillé pour le compte du  ''[[w :National Park Service|National Park Service]]'' (NPS) pendant plus de 40 ans, à partir de 1958, en qualité de photographe en chef pour le ''[[w:en :Historic American Buildings Survey|Historic American Buildings Survey]]'' (HABS).

En 1966 il a quitté le NPS pour deux ans, afin de superviser le ''New Jersey's State Historic Preservation Program'', un programme de sauvegarde du patrimoine historique de l'état, comprenant entre autres la gestion de 18 musées, de plusieurs phares et de deux villages historiques. En 1970, de retour à son ancien poste, il a repris le travail hautement spécialisé consistant à établir une documentation architecturale en grand format. Il a travaillé dans 49 états, des Îles Vierges à Porto Rico. 

Avril 2008 marqua le cinquantième anniversaire de son activité au sein du programme HABS. Il voyageait avec 450 kg d'équipement.

== Carrière professionnelle ==

Boucher travailla d'abord dans un laboratoire photographique, ensuite comme chef de gravure au journal ''Atlantic City Tribune'' et, de février 1951 à septembre 1952, chez ''Fred Hess &amp; Son Photographers'', à Atlantic City, New Jersey. De septembre 1952 à avril 1958 il devint chef photographe au ''Garden State Parkway'' du New-Jersey. Il tint pendant deux ans une chronique hebdomadaire sur la conservation et la préservation pour la ''Tribune'' et le '' Atlantic City Press''. Il a aussi produit et présenté une émission d'une heure sur la conservation et la préservation pour la radio WFPG d'Atlantic City, dans le New Jersey. Il quitta ensuite le ''Parkway'' pour travailler au ''National Park Sevice''.

Il fut d'abord chargé de travailler conjointement avec la branche de Washington de ''Still and Motion Pictures'' sous l'autorité du chef de branche Ralph Anderson, et avec ''Historic Structures at the NPS Eastern Office of Design and Construction'' à Philadelphie.

De 1958 à 1962, Boucher a documenté une des périodes les plus significatives dans l'histoire du NPS : la mission 66, un programme de conception et de construction destiné à revitaliser les parcs nationaux par un programme massif d'investissements étalé sur 10 ans. En 1963, il devint Photographe en chef de l'enquête sur les édifices historiques états-uniens. De 1971 à 1978, Boucher a aussi exécuté tout le travail de photographie pour un ouvrage sur les ouvrages d'art historiques états-uniens. Il est mort le 2 septembre 2012, à l'âge de 80 ans.

== Moments forts de sa carrière ==

[[File:Fumigation Hall Kalaupapa.jpeg|thumb|240px|left|Fumigation Hall à la léproserie de Kalaupapa, 1991]]
[[Image:Mar-A-Lago1.jpg|right|thumb|Entrée de Mar-A-Lago, Palm Beach, Floride, 1967.]]
[[Image:Racquet-club.jpg|thumb|Racquet and Tennis Club, New York City, 1965.]]
[[Image:Thomas Viaduct LOC 082103pu.jpg|thumb|Thomas Viaduct, Elkridge, Maryland, 1977.]]
[[Image:Melrose-natchez-2.jpg|thumb|Natchez National Historical Park, ''Melrose'' mansion, Natchez, Mississippi (1992).]]

Boucher a traaillé 18 heures sans interruption pour photographier un ouragan qui a ravagé Atlantic City, en novembre 1950, portant sa chambre 4 x 5 &quot; Speed Graphic à bouts de bras, avec de l'eau jusqu'aux aisselles.

En 1967, alors qu'il cherchait des points de vue pour photographier la forteresse El Morro dans le Vieux San Juan de Porto Rico, Boucher et sa femme Peggy étaient à bord d'un catamaran qui fut heurté et coupé en deux par un sous-marin entrant dans le port. Pendant les années 1990 il a produit plus de 500 photographies de grand format de la Maison Blanche pour l'Enquête sur les bâtiments historiques états-uniens, produisant parfois une seule photo par jour. Une de ses fiertés était un livre publié par la Maison Blanche, consacré au logement familial et  illustré par son travail. Son exemplaire lui était personnellement dédicacé par le Président et la Première Dame.

La mission dont il était le plus fier fut les trois semaines passées à décrire par la photographie le fonctionnement de la léproserie de Kaulapapa, dans l'île hawaïenne de Molokai, mission pendant laquelle il vécut au milieu des 85 malades toujours présents à l'époque. « Je me rappelle très clairement que j'étudiais l'histoire du prêtre belge Fr. Damien, qui travailla 16 ans parmi les lépreux. Je n'avais jamais rêvé que je pourrais aller à cet endroit-là ».

En 1969, Boucher a suivi grâce au ''National Trust of England'', à la ''Attingham School'', un programme d'étude estival traitant des manoirs historiques de l'Angleterre et de l'arcitecture depuis l'époque romaine jusqu'à celle de la Régence. Vers 1973 il fut un des 36 candidats choisis pour participer à l'École européenne itinérante d'été pour l'étude et la préservation de l'architecture historique. C'était un voyage d'étude de 7 semaines à travers l'Angleterre, la France, les Pays-Bas et la Belgique.

Le périodique ''American Preservation Magazine'' a publié une série d'articles dans lesquels Boucher a écrit et montré les photographies de villes historiques dans le l'Union soviétique, la Belgique, la Hongrie et l'Italie.

Boucher a conçu et supervisé en 1964 la conservation, à Atlantic City, du phare d'Absecon qui fut construit en 1857, et celle des forges de Weymouth, qui dataient des années 1820. Auparavant, en 1952, alors qu'il était âgé de 21 ans seulement, il avait été l'une des deux personnes à l'origine de la protection des 400 km² de la forêt de Wharton, qui, outre trois villages historiques où l'on fabriquait du fer et du verre pendant la Révolution américaine, abrite 24 espèces d'orchidées sauvages ainsi que de très nombreux animaux, parmi lesquels la très rare rainette ''Hyla andersoni'', ou ''Pine Barrens Tree Frog''.

En 1952 il a personnellement guidé Mike Hudoba, un célèbre écrivain naturaliste, au cours d'une excursion de plusieurs jours en canoë sur les rivières de la forêt de Warton. Une fois, il a parlé d'une excursion en canoë de trois semaines, pour pêcher la truite, en pleine nature sauvage du Canada, à quelques centaines de km du cercle polaire arctique. En naviguant sur la rivière Bersimus, ils ont essayé d'atteindre le lac Boucher, mais ils n'ont pas pu effectuer le portage permettant de franchir les rapides.

{{clr}}

== Héritage et collections ==

Pendant plus de 5 décennies de service public, Boucher a produit plusieurs dizaines de milliers de photos, qui font partie du domaine public. Il a reçu diverses récompenses, en 1986 le ''Meritorious Service Award'' du ''Department of the Interior'', la ''Medal for Architectural Photography'' de l' ''American Institute of Architects'' et beaucoup d'autres de la part de l' ''Association for State and Local History'', du Sénat du New-Jersey, etc.

Il a beaucoup enseigné dans les Universités, comme ''Columbia University'', ''College of William &amp; Mary'', ''Cornell University'', ''Ball State University'', ''[University of Florida'', ''University of Texas at Austin'', ''Franklin Pierce University'', auprès des sociétés d'histoire et de sauvegarde du patrimoine et dans d'autres établissements à travers tout le pays. Pendant quelques 15 ans il a enseigné la photographie d'architecture à l'Université de Nantucket, Massachusetts, et animé un stage estival de 9 semaines sur la préservation à l'École d'Architecture de l'Université de Floride.

D'importantes expositions de son travail ont eu lieu, par deux fois à la ''[[w:en:Library of Congress|Librairie du Congrès]]'', à l'Institut américain des Architectes, à l'Atheneum de Philadelphie, au Musée d'Histoire de Buffalo, à New-York, Porto-Rico, etc.

On estime que plus de 50 000 photographies de Boucher se trouvent dans les collections de la Librairie du Congrès, pour la plupart disponibles en ligne gratuitement ou our un prix modique sous forme de tirages sur papier. Boucher n'a jamais accepté la moindre commission privée et n'a jamais vendu de copies de ses œuvres.

==Publications==
[[Image:Quapaw Baths HABS 1984.jpg|thumb|Quapaw Baths in [[w:en:Bathhouse Row|Bathhouse Row]], Hot Springs National Park, Arkansas (1984).]]

* [http://books.google.com/books?id=Vk5YAAAAMAAJ&amp;q=born#search_anchor A Record in Detail: The Architectural Photographs of Jack E. Boucher] .- 1988, {{ISBN|0-8262-0640-9}}

* A Quest for Grandeur: Charles Moore and the Federal Triangle, texte de Sally Kress Tompkins .- {{ISBN|1-56098-161-X}}

* Landmarks of Prince George's County/Architectural Photographs .- {{ISBN|0-8018-4628-5}}

* Absegami Yesteryear .- Laureate Press: history of Atlantic County, NJ, 1964.

* Of Batsto &amp; Bog Iron .- Batsto Citizens Advisory Committee, 1964.

* Atlantic City's historic Absecon lighthouse .- Atlantic County Historical Society, 1964 [Il a présidé un comité qui a sauvé la tur de la destruction et supervisé sa restauration en 1963].

* Lucy, The Margate Elephant .- Save Lucy Committee, a National Historic Landmark, 1970.

* A Record In Detail .- University of Missouri Press.

* Quest for Grandeur .- Smithsonian Press

* Landmarks of Prince George's County .- [[w:en:Johns Hopkins University Press|Johns Hopkins Press]], 1993. {{ISBN|978-0801846281}}

* Under Four Flags .- California

* Architecture of Middle Tennessee .- Vanderbilt University Press, 1974. {{ISBN|978-0826511843}}

* Industrial Archeology .- Stephen Greene Press.

* etc.

== Voir aussi ==
*[[Commons:Category:Architectural photographers|''Architectural photographers'']]
*[[Commons:Category:HABS-HAER-HALS documentation|''HABS-HAER-HALS documentation'']]

== Références ==


Cet article est adapté de [[w:en:Jack Boucher|Jack Boucher dans la Wikipédia anglophone]].

== Liens externes ==

* [http://www.washingtonpost.com/local/obituaries/jack-e-boucher-longtime-national-park-service-photographer-dies-at-80/2012/09/13/f84323b4-fd01-11e1-b153-218509a954e1_story.html Obituary], Washington Post, September 14, 2012.

* [http://www.pressofatlanticcity.com/communities/atlantic-city_pleasantville_brigantine/a-life-lived-famous-photographer-got-his-first-shot-in/article_56c740a8-0f38-11e2-8902-001a4bcf887a.html A Life Lived: Famous photographer got his first shot in Atlantic City], Martin DeAngelis, The Press of Atlantic City, October 5, 2012.]

== Galerie de photographies ==
&lt;gallery widths=&quot;240px&quot; heights=&quot;240px&quot;&gt;
10 Broadway HABS CMHD.jpg
102 Ocean Boucher CMHD.jpg
12 Broadway Boucher.jpg
1667 Cambridge Street (Cambridge, Massachusetts) - 079996pv.jpg
1667 Cambridge Street (Cambridge, Massachusetts) - 079997pv.jpg
1667 Cambridge Street (Cambridge, Massachusetts) - 080000pv.jpg
1667 Cambridge Street (Cambridge, Massachusetts) - 080001pv.jpg
183rd St Station.jpg
1971 Central Station.jpg
1st United Method Boucher.jpg
1stChurchofChrist FarmingtonCT.jpg
2223 Green St (cropped).jpg
223-27 Chestnut Street Philadelphia HABS138436pv cropped.jpg
46 Station Street (House), Southport (Fairfield County, Conncecticut).jpg
511 Hughes Potts CMHD.jpg
5501 Germantown HABS Boucher.jpeg
6. IVY CITY ROUNDHOUSE. WASHINGTON, D. C. 030168pv.jpg
7th Reg. Armory - Park Ave exterior HABS NY,31-NEYO,121-7.jpg
7th Reg. Armory 1st Floor Silver (Trophy) Room HABS NY,31-NEYO,121-41.jpg
7th Reg. Armory 1st Floor Veterans (Tiffany) Room HABS NY,31-NEYO,121-21.jpg
7th Reg. Armory 2nd Floor, First Company Room HABS NY,31-NEYO,121-64.jpg
7th Reg. Armory First Floor Clark Room HABS NY,31-NEYO,121-36.jpg
7th Reg. Armory First Floor Colonel Reception Room HABS NY,31-NEYO,121-53.jpg
7th Reg. Armory Tiffany Room carved frieze HABS NY,31-NEYO,121-33.jpg
7th Reg. Armory, Tenth Company Room HABS NY,31-NEYO,121-92.jpg
7th Regiment Armory Main Staircase HABS NY,31-NEYO,121-17.jpg
815 Kearney CMHD.jpg
817 Kearney CMHD.jpg
A color photograph of the Bolduc House in Ste Genevieve MO.jpg
A Photograph of the Base of the Roof Truss in the Attic of the Bolduc House in Ste Genevieve MO.png
Abescon Light HABS Boucher.jpg
Abram Hatch House.jpg
Administration Building Hot Springs 1984.jpg
AERIAL VIEW FROM THE NORTH - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-30.tif
AERIAL VIEW FROM THE NORTHEAST - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-29.tif
AERIAL VIEW FROM THE SOUTHEAST - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-32.tif
AERIAL VIEW FROM THE SOUTHEAST, CLOSEUP OF GREENHOUSE - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-33.tif
AERIAL VIEW LOOKING NORTH. FRANKFORD CREEK IN FOREGROUND. - Frankford Arsenal, South of Tacony Street between Bridge Street and tracks of former Pennsylvania Railroad, HAER PA,51-PHILA,693-3.tif
AERIAL VIEW LOOKING NORTHWEST. BUILDINGS IN FOREGROUND ARE STOREHOUSES DATING FROM THE MID 20TH CENTURY. - Frankford Arsenal, South of Tacony Street between Bridge Street and HAER PA,51-PHILA,693-4.tif
AERIAL VIEW LOOKING SOUTHEAST. ARSENAL RUNS FROM LEFT TO RIGHT ACROSS CENTER OF PICTURE. ORIGINAL ARSENAL BORDERS PARADE GROUND AT RIGHT. - Frankford Arsenal, South of Tacony HAER PA,51-PHILA,693-1.tif
AERIAL VIEW LOOKING SOUTHWEST, SHOWING GROWTH OF ARSENAL OUTWARD FROM FROM ORIGINAL SITE (CENTER RIGHT). - Frankford Arsenal, South of Tacony Street between Bridge Street and HAER PA,51-PHILA,693-6.tif
AERIAL VIEW LOOKING WEST. LAND IN FOREGROUND WAS AQUIRED IN 1917. - Frankford Arsenal, South of Tacony Street between Bridge Street and tracks of former Pennsylvania Railroad, HAER PA,51-PHILA,693-5.tif
AERIAL VIEW NORTHEAST ALONG THE DELAWARE AVENUE CORRIDOR FROM FORT MCNAIR. - Delaware Avenue, Washington, District of Columbia, DC HABS DC,WASH,592-1.tif
AERIAL VIEW NORTHEAST ON DELAWARE AVENUE CORRIDOR FROM OVER THE U.S. CAPITOL GROUNDS. - Delaware Avenue, Washington, District of Columbia, DC HABS DC,WASH,592-3.tif
AERIAL VIEW NORTHEAST ON DELAWARE AVENUE FROM ABOVE THE U.S. CAPITOL. - Delaware Avenue, Washington, District of Columbia, DC HABS DC,WASH,592-2.tif
AERIAL VIEW OF DELAWARE AVENUE, LOOKING SOUTHWEST FROM FLORIDA AVENUE, NE. - Delaware Avenue, Washington, District of Columbia, DC HABS DC,WASH,592-6.tif
AERIAL VIEW OF GENERAL VIEW OF GREENHOUSE AREA - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-14.tif
AERIAL VIEW OF GREENHOUSE, LOOKING NORTHWEST - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-18.tif
AERIAL VIEW OF GREENHOUSE, LOOKING SOUTH - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-17.tif
AERIAL VIEW OF GREENHOUSES AND GARDENS - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-11.tif
AERIAL VIEW OF GREENHOUSES AND GARDENS, LOOKING NORTHEAST - Lyndhurst, Greenhouse, 635 South Broadway, Tarrytown, Westchester County, NY HABS NY,60-TARY,1B-12.tif
AERIAL VIEW OF P STREET BRIDGE.jpg
AERIAL VIEW OF P STREET BRIDGE.tif
AERIAL VIEW OF THE EASTERN SPANS OF THE SUSQUEHANNA RIVER BRIDGE. THE SPAN ON THE LEFT OF THE PHOTO IS A PENNSYLVANIA THROUGH TRUSS, THE ONE IN THE RIGHT A PENNSYLVANIA DECK TRUSS. HAER MD,13-HAV,4-7.tif
AERIAL VIEW OF THE PENNSYLVANIA THROUGH TRUSS SPAN ON THE WESTERN PORTION OF THE SUSQUEHANNA RIVER BRIDGE, LOOKING SOUTHEAST - Susquehanna River Bridge, Spanning Susquehanna River, HAER MD,13-HAV,4-14.tif
AERIAL VIEW SOUTHWEST ALONG DELAWARE AVENUE CORRIDOR FROM ABOVE UNION STATION. - Delaware Avenue, Washington, District of Columbia, DC HABS DC,WASH,592-4.tif
AERIAL VIEW SOUTHWEST ALONG DELAWARE AVENUE CORRIDOR FROM FLORIDA AVENUE, NE. - Delaware Avenue, Washington, District of Columbia, DC HABS DC,WASH,592-5.tif
Alcorn State University, Oakland Chapel, Alcorn State University Campus, Alcorn vicinity (Claiborne County, Mississippi).jpg
Alexander Campbell Mansion, Route 67, Bethany (Brooke County, West Virginia).jpg
Alfred Dunk House, 4 Pine Street, Binghamton (Broome County, New York).jpg
Allen Nichols House, 494 Harbor Road, Southport (Fairfield County, Connecticut).jpg
Allendale Mill 1969.jpg
Allison Mansion.jpg
Alonzo Roberson House, 30 Front Street, Binghamton (Broome County, New York).jpg
Ames Monument (Laramie, Wyoming).jpg
Amtrak Anacostia River Bridge 1977.jpg
Andalusia, State Road vicinity (Bensalem Township), Andalusia (Bucks County, Pennsylvania).jpg
Andrew F. Scott House.jpg
Arcade stairway.jpg
&lt;/gallery&gt;

{{T|[[Commons:Category:Jack Boucher|voir d'autres photographies de Jack Boucher sur Wikimedia Commons (plus de 1 600 disponibles)]]}}

{{Ph Personnalités}}</text>
      <sha1>npx7iwo3xv3xe1pi13oe3qzxbekn7nl</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Sociétés et Organisations/Éditeurs de cartes postales/Buisson</title>
    <ns>0</ns>
    <id>65993</id>
    <revision>
      <id>684270</id>
      <parentid>551934</parentid>
      <timestamp>2022-08-27T18:12:24Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="369" xml:space="preserve">{{Ph s Sociétés}}


'''Buisson''' était un éditeur de cartes postales installé à Saint-Étienne (Loire).

== Galerie de photographies ==
&lt;gallery widths=&quot;240px&quot; heights=&quot;240px&quot;&gt;
XXe s - Gare de Gouhenans - 05.jpg|Gare de Gouhénans

Saint-Paul-en-Jarez (Loire), chapelle de Lachal.jpg|Saint-Paul-en-Jarez (Loire), chapelle de Lachal
&lt;/gallery&gt;


{{Ph Sociétés}}</text>
      <sha1>rl1ifcynq63b8h2g5fqtmn5xe6npvai</sha1>
    </revision>
  </page>
  <page>
    <title>Pour lire Platon/Études de quelques passages des dialogues</title>
    <ns>0</ns>
    <id>66317</id>
    <revision>
      <id>684264</id>
      <parentid>674239</parentid>
      <timestamp>2022-08-27T18:07:15Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="19231" xml:space="preserve">&lt;noinclude&gt;{{Pour lire Platon}}&lt;/noinclude&gt;

{|class=wikitable
|&lt;strong&gt;Étude de la Lettre VII de Platon 
Platon naquit probablement en 427 avant J. C. et mourut aux alentours de 347 avant J. C. à l'âge d'environ 80 ans.
Il appartenait à une famille aristocratique de la ville d'Athènes qui était l'une des plus puissantes cités et l'un des grands centres culturels de la [[Grec ancien/La Grèce antique|Grèce antique]].&lt;/strong&gt;
|[[Image:Plato_Pio-Clemetino_Inv305.jpg|290px]]
|} 
== Étude d'un extrait de la Lettre 7 ==

==== Texte ====
&lt;blockquote&gt;''&quot;Mais, je ne sais comment cela se fit, voici que des gens puissants traînent devant les tribunaux ce même Socrate, notre ami, et portent contre lui une accusation des plus graves qu'il ne méritait certes point : c'est pour impiété que les uns l'assignèrent devant le tribunal et que les autres le condamnèrent, et ils firent mourir l'homme qui n'avait pas voulu participer à la criminelle arrestation d'un de leurs amis alors banni, lorsque, bannis eux-mêmes, ils étaient dans le malheur. Voyant cela et voyant les hommes qui menaient la politique, plus je considérais les lois et les mœurs, plus aussi j'avançais en âge, plus il me parut difficile de bien administrer les affaires de l'État. D'une part, sans amis et sans collaborateurs fidèles, cela ne me semblait pas possible. - Or, parmi les citoyens actuels, il n'était pas commode d'en trouver, car ce n'était plus selon les us et coutumes de nos ancêtres que notre ville était régie. Quant à en acquérir de nouveaux, on ne pouvait compter le faire sans trop de peine. - De plus, la législation et la moralité étaient corrompues à un tel point que moi, d'abord plein d'ardeur pour travailler au bien public, considérant cette situation et voyant comment tout marchait à la dérive, je finis par en être étourdi. Je ne cessais pourtant d'épier les signes possibles d'une amélioration dans ces événements et spécialement dans le régime politique, mais j'attendais toujours, pour agir, le bon moment. Finalement, je compris que tous les États actuels sont mal gouvernés, car leur législation est à peu près incurable sans d'énergiques préparatifs joints à d'heureuses circonstances. Je fus alors irrésistiblement amené à louer la vraie philosophie et à proclamer que, à sa lumière seule, on peut reconnaître où est la justice dans la vie publique et dans la vie privée. Donc, les maux ne cesseront pas pour les humains avant que la race des purs et authentiques philosophes n'arrive au pouvoir ou que les chefs des cités, par une grâce divine, ne se mettent à philosopher véritablement.&quot;''&lt;/blockquote&gt;&lt;blockquote&gt;Extrait de la lettre VII de Platon
&lt;ref&gt;Ensemble des Lettres http://remacle.org/bloodwolf/philosophes/platon/cousin/lettres.htm&lt;/ref&gt;&lt;/blockquote&gt;

==== '''Cette lettre est une réflexion de Platon sur le gouvernement juste à partir de l’expérience qu’il a faite de l’injustice lors du procès de Socrate.''' ====

La réflexion naît du choc de l’expérience vécue. Dans cette lettre autobiographique écrite au soir de sa vie, Platon nous raconte comment la mort de Socrate l’a détourné de la politique et poussé vers la philosophie. Le texte se compose de trois moments : dans un premier temps, Platon rappelle les faits : la mort de Socrate, une mort injuste dont la démocratie est  responsable; puis dans un second moment, il entreprend une critique radicale du régime politique de toutes les Cités ; enfin dans un dernier temps, il pose par une métaphore médicale ce qui lui semble juste comme régime politique. Le texte passe ainsi du fait, ce qui s’est passé, au droit, ce qui devrait être.

==== '''Platon commence par poser les faits'''. ====
Il a un sentiment d’injustice très fort (''&quot;évènement intolérable&quot;''). C'est ce que l'on appelle &quot;l'indignation&quot;. Ce sentiment d’injustice aurait pu le conduire à une révolte stérile : la vengeance. Le sentiment est en effet spontané et peu réfléchi. Cependant, même si Platon est choqué par l’intolérable de la situation, il préfère s’en remettre à l’examen de la situation qui a conduit Socrate à boire la ciguë. Plutôt que de faire appel à  la violence, à la passion, Platon  examine, selon l'ordre de la raison, les conditions de réalisation de l’injustice ( &quot;''Plus j’approfondissais'' … &quot;). 

Il examine donc tout d’abord les faits du procès lui-même, faits qu’il analysera dans L’apologie de Socrate. Dans un second temps, ce sont les institutions qu’il réfléchit. Les lois et les règles coutumières sont ainsi analysées. Notons que les lois, à la différence des règles coutumières, ne sauraient être variables. Par ailleurs les lois, comme le dit ici Platon, sont écrites, ce qui leur assure permanence et solidité. La coutume, au contraire, n’est pas écrite et peut, de ce fait, varier d’un groupe social à l’autre. À l’issue de cet examen, que constate Platon ? Une corruption « prodigieusement grande » de ces lois et règles. Ce qui est corrompu c’est ce qui n’est pas viable, le politique est donc malade. (on notera l’importance des termes relatifs à la maladie dans ce texte) Pourquoi s’interroger sur les institutions elles-mêmes ? Pourquoi réfléchir le sens des règles et des lois ? Tout simplement parce qu’il ne saurait y avoir de justice sans la médiation de ces institutions. C’est parce qu’il y a des lois qu’une juste distance s’introduit entre l’offensé et l’offenseur. La loi, la coutume nous protègent de la vengeance où il n’y a aucune distance, où tout se règle selon l’ordre des passions (voir la vendetta). La vengeance n’est pas équitable, elle est pur rapport de force. Qu’en conclut Platon ? On ne peut agir justement si les fondations de la Cité sont mauvaises, la politique n’est pas une affaire d’ignorance. Cela explique pourquoi il insiste sur la nécessité pour lui de différer le moment de l’action politique. Pour Platon, il n’y a pas de différence entre la théorie politique et l’action politique. D’où vient la corruption du système politique ? Si l’on en reste aux faits du procès, des démagogues. Anytos, l’un des accusateurs de Socrate, en est un très bon exemple. Que fait le démagogue ? Il flatte la foule. .. et croyant gouverner cette dernière se laisse en fait gouverner par elle, prisonnier de l’image qu’il doit lui donner. Quel est le régime politique d’Athènes, responsable de la mise à mort de Socrate ? La démocratie. L’expérience que Platon fait est celle de l’échec de la démocratie athénienne incapable de rendre justice. La démocratie c’est, étymologiquement le pouvoir du peuple. Or, Platon ne voit dans le peuple qu’une foule incapable de voir l’intérêt commun. La foule est ignorante, mais gouvernée par ses passions, elle est la proie facile des démagogues. La foule ne sait pas en quoi consiste la justice qu’elle confond avec la vengeance. 

==== '''Dans le second moment du texte, Platon élargit la problématique. Il n’y a pas que la démocratie qui est impuissante à penser la justice'''  ====
« ''Toutes les cités existant à l’heure actuelle, je me dis que toutes sans exception, ont un mauvais régime.'' » Par cette phrase Platon manifeste une certaine radicalité : aucun régime politique n’est capable de rendre justice, à moins que, comme il le dit fort ironiquement, le hasard ne fasse bien les choses (« ''Sous de favorables auspices''. ») Autant dire qu’il y a fort peu de chances qu’un tel régime existe. Il s’agit donc de repenser le régime politique capable d’instituer des lois au service de la justice. Pour Platon, il faut trouver le remède, le bon régime au sens médical du terme, car la maladie n’est que « quasi-incurable ». Le philosophe se fait médecin.  Il reste donc une chance de trouver une solution, mais cette dernière doit se réfléchir avant toute action. Aristote réfutera cette thèse de Platon dans les  Politiques  ou l’Éthique à Nicomaque . Pour lui, la politique n’est pas affaire de science : on peut être un grand savant sans pour autant savoir agir. Dans un autre ordre d’idée, on peut être un grand architecte sans savoir pour autant construire une maison. Il y a une distinction très nette chez Aristote entre la Theoria (la science) et Poiesis  (savoir-faire). On n’est pas artisan parce que l’on a des connaissances. De même, dans le champ politique, ce n’est pas parce que l’on a des connaissances sur la justice, qu’on saura forcement les appliquer dans le champ pratique (Praxis). La politique pour Aristote n’est pas une affaire de connaissances (il n’aurait pas apprécié l’expression Science-Po) mais de prudence. L’homme politique est celui qui pense les moyens de l’action et non une théorie de l’action. Platon est effectivement bien loin d’une telle conception. S’il est anti-démocrate, comme nous l’avons plusieurs fois souligné, il n’en est pas moins opposé aux régimes monarchiques, aristocratiques ou oligarchiques ambiants. Le fait ne fait pas le droit. Aucun régime existant ne correspond à un régime réellement juste, faute d’avoir réfléchi le sens du mot « juste ». Le mot ne fait pas le concept.

==== '''C’est pourquoi le texte s’achève sur la philosophie et son devoir de réfléchir le politique'''. ====
Comme, cependant, il n’y a pas de justice effective sans connaissance du juste, Platon confie le gouvernement de la Cité à celui qui a le « naturel philosophe ». Arrêtons-nous sur une telle expression. À la différence des sophistes Platon pense que la politique n’est pas l’affaire de tous. Elle ne peut que concerner celui qui réfléchit rationnellement  ou qui a  reçu une révélation divine. Ces deux solutions manifestent un certain pessimisme de la part de Platon, comme si ces deux solutions étaient impossibles. Dans La République il éclaircira à l’aide d’une allégorie ce naturel philosophe destiné au pouvoir politique. Arraché contre son gré à la caverne des ombres ce « naturel philosophe » devra supporter plusieurs épreuves avant d’accéder à la contemplation du soleil, image du bien et du juste. Bien sûr, une telle élévation ne va pas sans douleur et comme le dit l’allégorie : « le premier éblouissement fut brutale ». Cependant notre élève avait une prédisposition à la philosophie : il accepta la douleur. Tout aurait pu en rester là , sauf qu’il devait redescendre. La tâche du philosophe n’est pas de rester à contempler les idées mais de les réaliser dans la cité. Il lui fallu donc redescendre dans la caverne du préjugé et supporter un second éblouissement. Il avait néanmoins vu le juste, il lui fallait le mettre en pratique. C’était sans compter sur la foule agressive à son égard, menée par ses passions. Dans cette allégorie on voit bien que la vérité échappe à la foule. C’est pourquoi dans cette lettre Platon en appelle à une dispensation divine comme s’il nous suggérait que ce qui devrait être est encore loin d’arriver. Pour finir on pourrait se demander pourquoi le philosophe est seul apte à gouverner la cité ? Bien sûr, comme nous venons de le dire parce qu’il a eu accès à la contemplation du bien et du juste mais surtout parce qu’il déteste le pouvoir. Pour Platon, seul peut gouverner celui qui n’aime pas gouverner.

=== ---&gt;&gt;&gt;&gt;&gt; Aller plus loin. Ce qu'Aristote dit de l'indignation : ===
[[Fichier:Platon et Aristote par Della Robbia détail.jpg|vignette|Platon et Aristote par Della Robia]]
{| class=&quot;wikitable&quot;
|+
|
|'''CHAPITRE IX''' Rhétorique Livre II&lt;blockquote&gt;'''I.''' L'opposé de la pitié, c'est principalement l'indignation ; car il y a opposition entre la peine que nous cause un malheur immérité et celle que, dans un même sentiment moral, nous éprouvons à la vue d'un succès immérité ; et, dans les deux cas, ce sentiment est honnête. '''II.''' En effet, il nous arrive nécessairement de compatir et de nous apitoyer quand le sort immérité est un échec, et de nous indigner quand c'est un succès : car ce qui a lieu contrairement à notre mérite est injuste ; voilà pourquoi nous attribuons aux dieux même le sentiment de l'indignation ('''40''').&lt;/blockquote&gt;&lt;blockquote&gt;'''III.''' L'envie pourrait sembler, au même point de vue, être l'opposé de la pitié, comme se rapprochant de l'indignation et s'identifiant avec elle ; mais c'est autre chose. Il y a bien aussi, dans l'envie, un chagrin qui nous trouble et que suscite aussi la vue d'un succès ; seulement ce n'est pas, alors, le succès d'un indigne qui nous affecte, mais celui d'un égal ou d'un semblable. C'est cette considération, non pas qu'il nous arrivera autre chose, mais que cette chose nous arrivera à cause du prochain lui-même, qui frappe semblablement l'esprit de tout le monde ('''41''') car il n'y aura plus envie dans un cas et pitié dans l'autre, mais la crainte, si un chagrin, ou un trouble, nous est causé par la circonstance que quelque inconvénient ne résulte pour nous du succès d'un autre. '''IV.''' Il est évident que des sentiments contraires seront la conséquence de ces éventualités. Celui qu'afflige la réussite de gens qui n'en sont pas dignes se réjouira ou, du moins, ne sera pas péniblement affecté de l'échec des gens placés dans une situation contraire ('''42'''). Par exemple, à la vue de parricides ou d'assassins quelconques subissant leur châtiment, personne, parmi les gens de bien, ne pourrait éprouver de peine ; car on doit plutôt se réjouir d'un tel dénouement. De même aussi à la vue de ceux qui remporteront un succès mérité.&lt;/blockquote&gt;&lt;blockquote&gt;Les deux solutions sont justes et réjouissent le cœur de l'homme équitable ; car il y puise, nécessairement, l'espoir que ce qui sera arrivé à son semblable lui arrivera aussi à lui-même. '''V.''' Tous ces divers cas sont empreints du même caractère moral, et leurs contraires, du caractère contraire. Celui qui se réjouit du mal des autres est, en même temps, envieux ; car, étant donnée telle chose qu'il nous est pénible de voir se produire ou exister, nécessairement on sera heureux de la non-existence, ou de la destruction de cette même chose. Voilà pourquoi toutes ces dispositions d'esprit ('''43''') qui empêchent, les unes comme les autres, la pitié de naître, mais diffèrent entre elles pour les motifs précités, contribuent d'une façon semblable à faire qu'il n'y ait pas de place pour la pitié.&lt;/blockquote&gt;&lt;blockquote&gt;'''VI.''' Parlons d'abord de l'indignation et voyons contre qui l'on s'indigne ; pour quels motifs ; dans quel état d'esprit ; puis nous examinerons d'autres passions. '''VII.''' On voit clairement ce qu'il en est d'après les explications qui précédent. En effet, si l'indignation consiste à s'affliger de voir quelqu'un réussir sans le mériter, il est dès lors évident que toutes les sortes de biens indistinctement ne feront pas naître l'indignation.&lt;/blockquote&gt;&lt;blockquote&gt;'''VIII.''' Ce ne sera jamais un homme, juste, ou brave, ou vertueux, qui suscitera l'indignation (car les diverses espèces de pitié n'auront pas de raison d'être à propos des contraires de ces qualités) ('''44''') mais ce sera la richesse, le pouvoir et tels avantages dont, pour parler en général, sont dignes les gens de bien et ceux qui possèdent des biens naturels ; comme, par exemple, la noblesse, la beauté et toutes autres choses analogues ('''45'''). '''IX.''' De plus, comme ce qui est ancien parait se rapprocher de ce qui est naturel, il en résulte nécessairement que, en présence d'un même bien donné, c'est contre ceux qui le possèdent depuis peu et lui doivent la prospérité que l'on s'indigne le plus vivement ('''46'''). Car la vue des gens nouvellement riches nous affecte plus que celle des gens qui le sont d'ancienne date et de naissance. Il en est de même de ceux qui possèdent l'autorité, la puissance, un grand nombre d'amis, une belle famille et tous les avantages analogues et, pareillement, s'il en résulte pour eux quelque autre bien encore. Et en effet, dans ce cas-là, les gens investis de l'autorité, s'ils sont riches depuis peu, nous affligent plus que lorsqu'ils sont riches d'ancienne date.&lt;/blockquote&gt;&lt;blockquote&gt;'''X.''' On peut en dire autant des autres cas ('''47''') ; et la raison, c'est que les uns semblent posséder ce qui nous revient, et les autres, non : car ce qui nous apparaît comme ayant toujours été ainsi nous semble être de bon aloi, et, par suite, les autres posséder ce qui ne leur appartient pas. '''XI.''' Et, comme chacun des biens n'est pas mérité par n'importe qui, mais qu'ils comportent une certaine corrélation et convenance (par exemple, la beauté des armes n'a pas de rapport de convenance avec le juste, mais avec le brave ; ni les brillants mariages avec les gens nouvellement enrichis ('''48'''), mais avec les nobles), conséquemment, si, tout en étant un homme de bien, on n'obtient pas un avantage qui réalise cette convenance, il y a place pour l'indignation ; et de même encore, si l'on voit un inférieur entrer en lutte avec un supérieur et, surtout, si le conflit porte sur un même objet. De là ces vers :&lt;/blockquote&gt;&lt;blockquote&gt;'''XII.''' On est disposé à s'indigner (d'abord) dans le cas où l'on vient à mériter les plus grands biens et à les acquérir, car prétendre à des avantages semblables, quand on ne se trouve pas dans des conditions morales semblables, ce ne serait plus de la justice. '''XIII.''' En second lieu, dans le cas où l'on est honnête et homme de valeur ; car, dans ce cas, on juge sainement et l'on hait l'injustice.&lt;/blockquote&gt;&lt;blockquote&gt;'''XIV.''' De même, si l'on a de l'ambition et un vif désir d'accomplir certaines actions et, surtout, si notre ambition a pour objectif tel avantage dont les autres seraient précisément indignes. '''XV.''' En un mot, et d'une manière générale, ceux qui prétendent mériter telle chose dont ils ne jugent pas les autres dignes sont enclins à s'indigner contre ceux-ci, et à l'occasion de cette même chose. Voilà pourquoi les caractères serviles, sans valeur et sans ambition, ne sont pas susceptibles de s'indigner : il n'est rien dont ils se puissent croire eux-mêmes être dignes.&lt;/blockquote&gt;&lt;blockquote&gt;'''XVI.''' On voit aisément, d'après cela, dans quelles circonstances la malchance, les échecs, le manque de réussite des autres doivent nécessairement nous réjouir ou, du moins, nous laisser indifférents. Les explications qui précèdent donnent une idée claire des circonstances opposées. Par conséquent, si le discours met les juges dans une telle disposition, et que les personnes qui prétendent avoir droit à notre pitié, ainsi que les motifs allégués pour la faire naître, soient présentés comme indignes d'arriver à ce résultât et comme méritant plutôt de ne pas l'obtenir, il deviendra impossible que la pitié soit excitée.&lt;/blockquote&gt;
|
|}   


__INDEX__
[[Catégorie:Pour lire Platon (livre)]]</text>
      <sha1>6cgdwkrx7f88c9dr2pp4eecfiuxdgb7</sha1>
    </revision>
  </page>
  <page>
    <title>Grec ancien/Texte de Pausanias</title>
    <ns>0</ns>
    <id>66432</id>
    <revision>
      <id>684260</id>
      <parentid>639821</parentid>
      <timestamp>2022-08-27T18:05:21Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="15997" xml:space="preserve">&lt;noinclude&gt;{{Grec ancien}}&lt;/noinclude&gt;

{{Titre|&lt;strong&gt;ΠΑΥΣΑΝΙΟΥ ΕΛΛΑΔΟΣ ΠΕΡΙΗΓΗΣΙΣ&lt;/strong&gt;&lt;br&gt;&lt;small&gt;Description de la Grèce, Elide 1, Chapitre I&lt;/small&gt;|Pausanias|Traduction Etienne Clavier}}
&lt;div style=&quot;text-align: center;&quot;&gt;
{| width=60% cellspacing=10 border=0 |
|-
|width=5%|
|width=30%|
|width=5%|
|width=30%|
|-
| colspan=4 |


&lt;/div&gt;
|-
|-
 !
 ! align=center bgcolor=#f5f5dc|ΠΑΥΣΑΝΙΟΥ ΕΛΛΑΔΟΣ ΠΕΡΙΗΓΗΣΙΣ· ΗΛΙΑΚΗ Α

ΚΕΦΑΛΑΙΟΝ Α'.
 !
 ! align=center bgcolor=#f5f5dc|DESCRIPTION DE LA GRECE: LIVRE V 

CHAPITRE Ι


|-
| valign=top align=right|'''1'''
| valign=top|
'''Πελοποννήσου μερισμός. Ἀρχὴ Ἠλείων, Ἐπειῶν καὶ Αἰτωλῶν. Οἰνόμαος καὶ Πέλοψ. Αὐγέας καὶ Ἡρακλῆς Ἁμαρυγκεύς. Ἄκτωρ καὶ παῖδες αὐτοῦ.'''

Ὅσοι δὲ Ἑλλήνων Πελοποννήσου πέντε εἶναι μοίρας, καὶ οὐ πλείονάς φασιν, ἀνάγκη σφᾶς ὁμολογεῖν, ὡς ἐν τῇ Ἀρκάδων οἰκοῦσιν Ἠλεῖοι καὶ Ἀρκάδες, δευτέρα δὲ Ἀχαιῶν, τρεῖς δὲ ἐπὶ ταύταις αἱ Δωριέων. Γένη δὲ οἰκεῖ Πελοπόννησον, Ἀρκάδες μὲν αὐτόχθονες, καὶ Ἀχαιοί. Καὶ οἱ μὲν ὑπὸ Δωριέων ἐκ τῆς σφετέρας ἀνέστησαν· οὐ μέντοι Πελοποννήσου γε ἐξεχώρησαν, ἀλλὰ ἐκβαλόντες Ἴωνας νέμονται τὸν Αἰγιαλὸν τὸ ἀρχαῖον, νῦν δὲ ἀπὸ τῶν Ἀχαιῶν τούτων καλούμενον.
 

| valign=top align=right|'''1'''
| valign=top|
'''Division du Péloponnèse. Origine des Éléens , des Épéens et des Étoliens. Oenomaüs et Pélops. Augias et Hercules. Amaryncde. Actor et ses fils.'''

Ceux des Grecs qui ne divisent le Péloponnèse qu'en cinq parties, sont forcés de comprendre sous le nom d'Arcadie, l'Arcadie proprement dite et le pays des Éléens. La seconde partie est occupée par les Achéens, et les trois autres par les Doriens. Les Arcadiens et les Achéens sont les seuls peuples Autochtones qui habitent le Péloponnèse ; les Achéens furent bien chassés de leur pays par les Doriens, mais ils ne sortirent pas de la presqu'île ; ils allèrent s'établir dans l'ancienne Aegiale, d'où ils chassèrent les Ioniens, et qui a pris d'eux le nom d'Achaïe qu'elle a conservé jusqu'à ce jour. 
|-
| valign=top align=right|'''2'''
| valign=top|
Οἱ δὲ Ἀρκάδες διατελοῦσιν ἐξαρχῆς καὶ ἐς τόδε τὴν ἑαυτῶν ἔχοντες. Τὰ δὲ λοιπὰ ἐπηλύδων ἐστὶν ἀνθρώπων. Κορίνθιοι μὲν γὰρ οἱ νῦν νεώτατοι Πελοποννησίων εἰσί, καί σφισιν ἀφ' οὗ τὴν γῆν παρὰ βασιλέως ἔχουσιν, εἴκοσιν ἔτη καὶ διακόσια τριῶν δέοντα ἦν ἐς ἐμέ. Δρύοπες δὲ καὶ Δωριεῖς, οἱ μὲν ἐκ Παρνασσοῦ, Δωριεῖς δὲ ἐκ τῆς Οἴτης ἐς Πελοπόννησόν εἰσιν ἀφιγμένοι.
| valign=top align=right|'''2'''
| valign=top|
Les Arcadiens sont encore dans le pays qu'ils ont originairement occupé. Les autres peuples sont venus d'ailleurs, et les Corinthiens actuels sont les plus nouveaux de tous les peuples du Péloponnèse; il n'y a eu effet que 217 ans que Jules César leur a donné cette contrée. Les Dryopes et les Doriens sont venus, les premiers du Parnasse; et les seconds, du mont Oeta ;
|-
| valign=top align=right|'''3'''
| valign=top|
Τοὺς Ἠλείους ἴσμεν ἐκ Καλυδῶνος διαβεβηκότας καὶ Αἰτωλίας τῆς ἄλλης. Τὰ δὲ ἔτι παλαιότερα ἐς αὐτοὺς τοιάδε εὕρισκον. Βασιλεῦσαι πρῶτον ἐν τῇ γῇ ταύτῃ λέγουσιν Ἀέθλιον, παῖδα δὲ αὐτὸν Διός τε εἶναι καὶ Πρωτογενείας τῆς Δευκαλίωνος, Ἀεθλίου δὲ Ἐνδυμίωνα γενέσθαι. 
| valign=top align=right|'''3'''
| valign=top|
et nous savons que les Éléens ont passé par mer, de Calydon et du reste de l'Étolie dans le Péloponnèse. Voici ce que j'ai appris de l'histoire de ce pays pour les temps antérieurs à leur arrivée. On dit qu'Aëthlius fut le premier roi de cette contrée ; qu'il était fils de Jupiter et de Protogénie, fille de Deucalion, et qu'il eut lui-même un fils nommé Endymion. 
|-
| valign=top align=right|'''4'''
| valign=top|
Τούτου τοῦ Ἐνδυμίωνος Σελήνην φασὶν ἐρασθῆναι, καὶ ὡς θυγατέρες αὐτῷ γένοιντο ἐκ τῆς θεοῦ πεντήκοντα. Οἱ δὲ δὴ μᾶλλόν τι εἰκότα λέγοντες, Ἐνδυμίωνι λαβόντι Ἀστεροδίαν γυναῖκα· οἱ δὲ τὴν Ἰτώνου τοῦ Ἀμφικτύονος Χρομίαν· ἄλλοι δὲ Ὑπερίππην τὴν Ἀρκάδος· γενέσθαι δ' οὖν φασιν αὐτῷ Παίονα καὶ Ἐπειόν τε καὶ Αἰτωλὸν, καὶ θυγατέρα ἐπ' αὐτοῖς Εὐρυκύδαν. Ἔθηκε δὲ καὶ ἐν Ὀλυμπίᾳ δρόμου τοῖς παισὶν ἀγῶνα Ἐνδυμίων ὑπὲρ τῆς ἀρχῆς, καὶ ἐνίκησε, καὶ ἔσχε τὴν βασιλείαν Ἐπειός· καὶ Ἐπειοὶ πρῶτον τότε ὧν ἦρχεν, ὠνομάσθησαν.
| valign=top align=right|'''4'''
| valign=top|
La Lune devint, à ce qu'il prétend, amoureuse d'Endymion et en eut cinquante filles. Mais il est plus vraisemblable qu'il épousa, comme le disent d'autres personnes, soit Astérodie, soit Chromie, fille d'Itonus, fils d'Amphyction ; soit enfin Hypérippe, fille d'Arcas. On dit donc qu'il eut trois fils, Paeon, Epéus, Aetolus, et une fille nommée Eurycyda. Il proposa dans Olympie, son royaume pour prix de la course à ses fils : Epéus ayant été vainqueur monta sur le trône, et ses sujets prirent alors le nom d'Epéens.
|-
| valign=top align=right|'''5'''
| valign=top|
Τῶν δὲ ἀδελφῶν Αἰτωλὸν μὲν καταμεῖναί φασιν αὐτοῦ, Παίονα δὲ ἀχθόμενον τῇ ἥττῃ, φυγεῖν ὡς πορρωτάτω, καὶ τὴν ὑπὲρ Ἀξιοῦ ποταμοῦ χώραν ἀπ' αὐτοῦ Παιονίαν ὀνομασθῆναι. Τὰ δὲ ἐς τὴν Ἐνδυμίωνος τελευτὴν, οὐ κατὰ τὰ αὐτὰ Ἡρακλεῶταί τε οἱ πρὸς Μιλήτῳ καὶ Ἠλεῖοι λέγουσιν, ἀλλὰ Ἠλεῖοι μὲν ἀποφαίνουσιν Ἐνδυμίωνος μνῆμα, Ἡρακλεῶται δὲ ἐς Λάτμον τὸ ὄρος ἀποχωρῆσαί φασιν αὐτὸν· καὶ ἄδυτον Ἐνδυμίωνός ἐστιν ἐν τῷ Λάτμῳ.
| valign=top align=right|'''5'''
| valign=top|
Des deux autres frères, Aetolus resta, dit-on, auprès de lui, mais Paon indigné de se voir vaincu s'enfuit au loin, et donna le nom de Pæonie au pays qu'arrose le fleuve Axius. Les Héracléotes du voisinage de Milet, ne sont point d'accord avec les Éléens sur la mort d'Endymion : ceux-ci en effet montrent son tombeau, tandis que les Héracléotes prétendent qu'il se retira sur le mont Latmos, qui renferme une chapelle d'Endymion où il n'est pas permis d'entrer. 
|-
| valign=top align=right|'''6'''
| valign=top|
Ἐπειῷ δὲ γήμαντι Ἀναξιρόην τὴν Κορώνου, θυγάτηρ μὲν Ὑρμίνα, ἄρσεν δὲ οὐκ ἐγένετο αὐτῷ γένος. Καὶ τάδε ἄλλα συνέβη κατ' Ἐπειὸν βασιλεύοντα. Οἰνόμαος ὁ Ἀλξίωνος (Ἄρεως δὲ, καθὰ ποιηταί τε ἐπεφήμισαν, καὶ τῶν πολλῶν ἐστιν ἐς αὐτὸν λόγος) οὗτος δυναστεύων περὶ τὴν Πισαίαν καλουμένην ὁ Οἰνόμαος, ἐπαύθη τῆς ἀρχῆς διαβάντος Πέλοπος τοῦ Λυδοῦ ἐκ τῆς Ἀσίας. 
| valign=top align=right|'''6'''
| valign=top|
Epéus ayant épousé Anaxiroé fille de Coronus n'en eut point de fils, mais seulement une fille nommée Hyrmina. Il se passa sous son règne divers événements dont je vais rendre compte. Oenomaüs, filg d'Alxion ( les poètes disent qu'il était fils dé Mars et c'est l'opinion la plus répandue), Oenomaüs, roi du pays de Pise, fut détrôné par Pélops le Lydien qui avait passé de l'Asie dans la Grèce ;
|-
| valign=top align=right|'''7'''
| valign=top|
Πέλοψ δὲ ἀποθανόντος Οἰνομάου τήν τε Πισαίαν ἔσχε, καὶ Ὀλυμπίαν, ἀποτεμόμενος τῆς Ἐπειοῦ χώρας ὅμορον οὖσαν τῇ Πισαίᾳ, Ἑρμοῦ τε ἐν Πελοποννήσῳ ναὸν ἱδρύσασθαι, καὶ θῦσαι τῷ θεῷ Πέλοπα ἔλεγον οἱ Ἠλεῖοι πρῶτον, ἀποτρεπόμενον τὸ ἐπὶ τῷ Μυρτίλου θανάτῳ μήνιμα ἐκ τοῦ θεοῦ.
| valign=top align=right|'''7'''
| valign=top|
Pélops devint roi de Pise après la mort d'Oenomaüs et conquit sur Epéus, Olympie qui était limitrophe de Pise. Les Éléens disent que Pélops érigea dans le Péloponnèse un temple à Mercure, et lui, offrit le premier des sacrifices pour apaiser sa colère provoquée par le meurtre de Myrtilus.
|-
| valign=top align=right|'''8'''
| valign=top|
Αἰτωλῷ δὲ μετὰ Ἐπειὸν βασιλεύσαντι, συνέπεσεν ἐκ Πελοποννήσου φυγεῖν, ὅτι αὐτὸν οἱ Ἄπιδος παῖδες ἐφ' αἵματι ἀκουσίῳ δίκην εἷλον. Ἆπιν γὰρ τὸν Ἰάσονος ἐκ Παλλαντίου τοῦ Ἀρκάδων ἀπέκτεινεν Αἰτωλὸς, ἐπελάσας τὸ ἅρμα τεθέντων ἐπὶ Ἀζᾶνι ἄθλων. )Απὸ μὲν Αἰτωλοῦ τοῦ Ἐνδυμίωνος οἱ περὶ τὸν Ἀχελῷον οἰκοῦντες ἐκλήθησαν, φυγόντος ἐς ταύτην τὴν ἤπειρον. Τὴν δὲ Ἐπειῶν ἔσχεν ἀρχὴν Ἠλεῖος Εὐρυκύδας τε τῆς Ἐνδυμίωνος καὶ (ὅτῳ πιστὰ) πατρὸς ὢν Ποσειδῶνος. Καὶ τὸ ὄνομα οἱ ἄνθρωποι τὸ νῦν ἀντὶ Ἐπειῶν ἀπὸ τοῦ Ἠλείου μεταβεβλήκασιν.
| valign=top align=right|'''8'''
| valign=top|
Aetolus qui monta sur le trône après la mort d'Apis fut exilé du Péloponnèse, les enfants d'Apis l'ayant fait condamner pour un meurtre involontaire. Il avait en effet tué Apis, fils de Jason de Pallantium en Arcadie, en poussant son char sur lui aux jeux funèbres d'Azan. Il alla sur le continent voisin de l'Achéloüs, et les peuples de cette contrée prirent de lui le nom d'étoliens. Le trône des Epéens passa alors à Eléius fils de Neptune (si on veut bien le croire), et d'Eurycyda, fille d'Endymion. Ses sujets quittèrent alors le nom d'Epéens et prirent celui d'Éléens qu'ils ont encore maintenant.
|-
| valign=top align=right|'''9'''
| valign=top|
Ἠλείου δὲ ἦν Αὐγέας. Οἱ δὲ ἀποσεμνύνοντες τὰ ἐς αὐτόν, παρατρέψαντες τοῦ Ἠλείου τὸ ὄνομα, Ἡλίου φασὶν Αὐγέαν παῖδα εἶναι. Τούτῳ βοῦς τῷ Αὐγέᾳ καὶ αἰπόλια τοσαῦτα ἐγένετο, ὡς καὶ τῆς χώρας αὐτῷ τὰ πολλὰ ἤδη διατελεῖν ἀργὰ ὄντα ὑπὸ τῶν βοσκημάτων τῆς κόπρου. Ἡρακλέα οὖν, εἴτε ἐπὶ μοίρᾳ τῆς Ἠλείας, εἴτε ἐφ' ὅτῳ δὴ καὶ ἄλλῳ μισθῷ, πείθει οἱ καθῆραι τῆς κόπρου τὴν γῆν.
| valign=top align=right|'''9'''
| valign=top|
Augias était fils d'Eleius ; ceux qui veulent lui donner une naissance plus illustre, font un petit changement au nom de son père et disent qu'il était fils d'Hélius (le Soleil) et non d'Eléius. Ses troupeaux de bœufs et de chèvres se multiplièrent tellement, que la plus grande partie du pays restait en friche à cause du fumier de ces animaux. Il engagea Hercules à enlever tout ce fumier, par la promesse qu'il lui fit d'une portion de l'Élide ou de tout autre salaire,
|-
| valign=top align=right|'''10'''
| valign=top|
Καὶ ὁ μὲν καὶ τοῦτο ἐξειργάσατο ἐκτρέψας τοῦ Μηνίου τὸ ῥεῦμα ἐς τὴν κόπρον. Αὐγέας δέ, ὅτι τῷ Ἡρακλεῖ σοφίᾳ πλέον καὶ οὐ σὺν πόνῳ τὸ ἔργον ἤνυστο, αὐτός τε ἀποδοῦναί οἱ τὸν μισθὸν ἀπηξίου, καὶ τῶν παίδων τῶν ἀρσένων τὸν πρεσβύτερον Φυλέα ἐξέβαλεν, ἀντειπόντα ὡς οὐ δίκαια ποιοῖτο πρὸς ἄνδρα εὐεργέτην. Αὐτὸς δὲ τά τε ἄλλα παρεσκευάζετο ὡς τὸν Ἡρακλέα ἀμυνούμενος, ἢν ἐπὶ τὴν Ἦλιν στρατεύηται, καὶ τοὺς παῖδας τοὺς Ἄκτορος καὶ Ἀμαρυγκέα ἐπηγάγετο ἐς φιλίαν. 
| valign=top align=right|'''10'''
| valign=top|
et Hercules en vint effectivement à bout en détournant le fleuve Médius et en le faisant passer dans les endroits que couvrait ce fumier. Augias sous prétexte qu'il avait mis plus d'industrie que de travail à cette opération, lui refusa le salaire convenu et chassa même de sa présence Phyleus son fils aîné qui lui faisait des représentations sur l'injustice de son procédé envers son bienfaiteur. Il commença dès lors à faire divers préparatifs pour se défendre si Hercules venait attaquer l'Élide, et contracta une alliance avec les fils d'Actor et avec Amaryncée ; 
|-
| valign=top align=right|'''11'''
| valign=top|
Ἦν δὲ ὁ Ἀμαρυγκεὺς, ἄλλως μὲν ἀγαθὸς τὰ ἐς τὸν πόλεμον· ὁ δέ οἱ πατὴρ Πυττίος Θεσσαλὸς τὰ ἄνωθεν ἦν, καὶ ἐς τὴν Ἠλείαν ἀφίκετο ἐκ Θεσσαλίας. Ἀμαρυγκεῖ μὲν δὴ καὶ ἀρχῆς ἐν Ἠλείᾳ μετέδωκεν ὁ Αὐγέας. Ἄκτορι δὲ καὶ τοῖς παισὶ γένος τε ἦν ἐπιχώριον, βασιλείας τε μετῆν σφισιν. Ἄκτωρ γὰρ πατρὸς μὲν Φόρβαντος ἦν τοῦ Λαπίθου, μητρὸς δὲ Ὑρμίνης τῆς Ἐπειοῦ. Καὶ ᾤκισεν ἀπ' αὐτῆς Ἄκτωρ πόλιν Ὑρμίναν ἐν τῇ Ἠλείᾳ.
| valign=top align=right|'''11'''
| valign=top|
ce dernier, qui était au reste un excellent guerrier, était fils de Pyttius, Thessalien, et avait quitté la Thessalie pour venir habiter l'Élide ; Augias lui donna une portion de son autorité. Pour Actor et ses fils, leur famille était du pays, et ils avaient part à la royauté. Actor était en effet fils de Phorbas fils de Lapithus, et d'Hyrmina fille d'Epéius. Il appela Hyrmina, du nom de sa mère, la ville qu'il fonda dans l'Elide.
|}
&lt;div class=&quot;text&quot;&gt;
&lt;br&gt;
&lt;/div&gt;

&lt;/div&gt;
== Étude du texte ==
{{Avertissement exercice}}

{{AutoCat}}</text>
      <sha1>0slm4j0haabbsomihhsb0qx2pzx5hjl</sha1>
    </revision>
  </page>
  <page>
    <title>MySQL/Débogage</title>
    <ns>0</ns>
    <id>67170</id>
    <revision>
      <id>684225</id>
      <parentid>670733</parentid>
      <timestamp>2022-08-27T12:39:42Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="11153" xml:space="preserve">&lt;noinclude&gt;{{MySQL}}&lt;/noinclude&gt;

== Introduction ==
Comme vu [[../Parcourir_les_bases_de_données#mysql|précédemment dans la description de la base &quot;mysql&quot;]], il peut être utile d'activer les logs sur l'historique des requêtes lors du débogage d'une application qui utilise MySQL.

== Gestion des exceptions ==
En MySQL, les anomalies du type &quot;division par zéro&quot; ne renvoient pas d'erreur mais NULL.

Toutefois il est possible de lever des exceptions lors des manipulations de table, par exemple pour éviter qu'une liste d'insertions s'arrête au milieu à cause d'une contrainte d'unicité. L'exemple ci-dessous fonctionne sur une table InnoDB (et pas MyISAM)&lt;ref&gt;http://stackoverflow.com/questions/2950676/difference-between-set-autocommit-1-and-start-transaction-in-mysql-have-i-misse&lt;/ref&gt; :

&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
ALTER TABLE `MaTable1` ADD UNIQUE(`id`);

INSERT INTO MaTable1 (id) VALUES('1');
START TRANSACTION;
      INSERT INTO MaTable1 (id) VALUES('2');
      INSERT INTO MaTable1 (id) VALUES('3');
      INSERT INTO MaTable1 (id) VALUES('1');
IF condition THEN
  COMMIT;
ELSE
  ROLLBACK;
END IF;
&lt;/syntaxhighlight&gt;
Ici une erreur surgit lors de la deuxième insertion d'un id=1. Selon une condition, on peut donc annuler les insertions de 2 et 3, ou bien les soumettre.

{{remarque|1=Par défaut, MySQL est en autocommit, cela signifie qu'un COMMIT est automatiquement effectué après chaque opération (rendant inutile les ROLLBACK). Pour le désactiver, lancer &lt;code&gt;SET autocommit = 0;&lt;/code&gt;}}

{{attention|S'il y a plusieurs COMMIT avant un ROLLBACK (par exemple dans une boucle), ce dernier n'annulera que les opérations consécutives au dernier COMMIT.}}

== Erreurs MySQL ==
=== A new statement was found, but no delimiter between it and the previous one ===
Ajouter un &quot;;&quot;.

Sinon avec &quot;DELIMITER&quot; : sans espace avant (donc consécutivement au retour chariot).

=== Access denied for user mon_compte@mon_hôte ===
* Vérifier le mot de passe du compte.
* Vérifier que l'hôte du compte n'a pas été changé par une règle réseau.
*:Si c'est le cas, tester en shell :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
 sudo mysql -h mon_hôte1 -u mon_compte
 sudo mysql -h mon_hôte2 -u mon_compte
&lt;/syntaxhighlight&gt;
* Sinon, recréer le droit avec :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
GRANT ALL PRIVILEGES ON *.* TO 'mon_compte'@'mon_hôte2' IDENTIFIED BY PASSWORD 'mon_mot_de_passe_hashé';
&lt;/syntaxhighlight&gt;

=== Base table or view not found: 1146 Table 'xxx' doesn't exist&quot; is not defined, use one of: 100, 200, 250, 300, 400, 500, 550, 600 ===
Une table temporaire n'est pas accessible, elle a peut-être été créée dans un autre thread : il faut la déplacer dans le même fichier.

=== BIGINT UNSIGNED value is out of range ===
Se produit sur les opérations sur les grands nombres. On peut alors manipuler des nombres plus petits, par exemple en convertissant les octets en gigas dans le select.

=== Can't create table 'xxx' (errno: 150)	===
Clé primaire invalide. Dans ce cas il vaut mieux séparer la création de la table puis l'ajout des contraintes en deux requêtes. Cela peut permettre par exemple de voir que les tables vers lesquelles pointent les contraintes doivent être créées avant ces dernières.

=== Can't connect to MySQL server ===
Changer le paramètre &quot;host&quot;.

=== Can't create federated table ===
Le schéma de la table distante doit être le même que celui de la table locale.

Sinon, activer les logs sur le serveur distant pour voir le compte qui se connecte.

=== Can't create/write to file 'mon_dossier/mon_fichier.csv' ===
Lors d'un SELECT INTO OUTFILE, si le compte du SGBD utilisé a les droits d'exportation (&lt;code&gt;GRANT FILE ON .* TO 'mon_compte'@'%';&lt;/code&gt;), le problème est lié au compte MySQL de l'OS qui n'a pas accès au système de fichier. Comme généralement le compte &quot;mysql&quot; sur Linux n'a pas de shell, cela peut se confirmer ainsi :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
su - -s /bin/bash mysql
touch mon_dossier/mon_fichier.csv
&lt;/syntaxhighlight&gt;

Si les droits manquent :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
sudo chown -R mysql mon_dossier
&lt;/syntaxhighlight&gt;

=== Cannot add foreign key constraint ===
Survient lors d'un &quot;CREATE TABLE&quot;, et ce n'est pas lié à la valeur de ''foreign_key_checks''.

En fait il ne faut pas créer de contrainte d'intégrité entre deux tables de moteur différent (ex : InnoDB vs MyISAM). 

=== Cannot drop index 'UNIQ_XXX': needed in a foreign key constraint ===
Il faut supprimer la clé étrangère avant l'index duquel elle dépend :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
ALTER TABLE `maTable` DROP FOREIGN KEY `FK_XXX`;
ALTER TABLE `maTable` DROP INDEX `UNIQ_XXX`;
&lt;/syntaxhighlight&gt;

=== Data too long for column ===
Si les données avec des caractères non ASCII étaient censées tenir dans le champ, on peut passer en mode strict :
&lt;code&gt;SET @@global.sql_mode= 'NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION';&lt;/code&gt;

Toutefois cela ne préserve pas leur encodage Unicode. Le mieux est donc :
&lt;syntaxhighlight lang=&quot;sql&quot;&gt;
SET NAMES 'utf8';
&lt;/syntaxhighlight&gt;

=== Foreign data src error ===
Lors du &lt;code&gt;create server&lt;/code&gt;, le compte renseigné n'existe pas.

=== Foreign key constraint is incorrectly formed ===
Une clé étrangère n'est pas au même format que la colonne à laquelle elle fait référence. Par exemple si cette dernière n'existe pas ou si elle n'a pas le même type.

=== Got error 'invalid character range' ===
L'utilisation de &lt;code&gt;\-&lt;/code&gt; est parfois proscrite en regex (ou il faut l'échapper autrement ?).

=== Host 'example.com' is not allowed to connect to this MySQL server ===
Dans le cas d'une [[MySQL/Sécurité#Ouverture_.C3.A0_un_PC_distant|connexion depuis un PC distant]], le compte utilisé n'est pas autorisé. Il faut donc le configurer avec :
 GRANT ALL PRIVILEGES ON *.* TO 'utilisateur'@'%' WITH GRANT OPTION;
au lieu ou en plus de :
 GRANT ALL PRIVILEGES ON *.* TO 'utilisateur'@'localhost' WITH GRANT OPTION;

=== Illegal mix of collations ===
Trois solutions :
* &lt;code&gt;ALTER TABLE&lt;/code&gt; pour changer la structure d'au moins une des deux tables jointes, pour uniformiser leur collation.
* &lt;code&gt;CAST(monChamp AS CHAR CHARACTER SET utf8)&lt;/code&gt;.
* &lt;code&gt;CONVERT(monChamp USING utf8)&lt;/code&gt;.

=== Invalid use of group function ===
* Dans le cas d'un &lt;code&gt;SELECT&lt;/code&gt;, il conviendrait d'utiliser &lt;code&gt;HAVING&lt;/code&gt; au lieu de &lt;code&gt;WHERE&lt;/code&gt; pour modifier des enregistrements en fonction d'autres d'une sous-requête.
* Pour un &lt;code&gt;UPDATE&lt;/code&gt; ou un &lt;code&gt;DELETE&lt;/code&gt;, les champs comparés par un &lt;code&gt;IN&lt;/code&gt; ne sont peut-être pas du même type.

=== Integrity constraint violation: 1217 Cannot delete or update a parent row: a foreign key constraint fails ===
Il manque un &quot;DROP FOREIGN KEY&quot; avant un &quot;DROP TABLE&quot; ou un &quot;DROP COLUMN&quot;.

Pour les supprimer, l'utilisateur root n'a pas le droit de modifier directement directement la table &quot;information_schema&quot;. Il faut donc exécuter les requêtes générées par la suivante :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
SELECT concat('alter table ',table_schema,'.',table_name,' DROP FOREIGN KEY ',constraint_name,';')
FROM information_schema.table_constraints
WHERE constraint_type='FOREIGN KEY'
AND table_name='maTable';
&lt;/syntaxhighlight&gt;

=== Lock wait timeout exceeded; try restarting transaction ===
Le serveur SQL est surchargé : exécuter les instructions une par une.
Sinon :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
SET innodb_lock_wait_timeout = 120; 
&lt;/syntaxhighlight&gt;

=== Query execution was interrupted, max_execution_time exceeded ===
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
SET GLOBAL MAX_EXECUTION_TIME = 1000; -- milisecondes
&lt;/syntaxhighlight&gt;

Dans MariaDB :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
SET GLOBAL max_statement_time = 1; -- secondes
&lt;/syntaxhighlight&gt;

=== View ... references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them ===
Temporairement on peut recréer la view sans &quot;SQL SECURITY INVOKER&quot;.

=== Specified key was too long; max key length is 3072 bytes ===
Se produit lors d'un ALTER vers un grand type comme &quot;text&quot;. Exemple :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
ALTER TABLE ma_table
CHANGE `mon_champ2` `mon_champ2` text COLLATE 'utf8_general_ci' NULL AFTER `mon_champ1`;
&lt;/syntaxhighlight&gt;
Solution :
&lt;syntaxhighlight lang=&quot;mysql&quot;&gt;
ALTER TABLE ma_table
CHANGE `mon_champ2` `mon_champ2` varchar(1000) COLLATE 'utf8_general_ci' NULL AFTER `mon_champ1`;
&lt;/syntaxhighlight&gt;

=== Syntax error or access violation ===
Utiliser phpMyAdmin pour trouver l'erreur de syntaxe.

Si cela survient après avoir collé une exportation de base, utiliser plutôt l'importation d'un .sql qui gère mieux les caractères d'échappement.

=== This version of MySQL doesn't yet support 'LIMIT &amp; IN/ALL/ANY/SOME subquery' ===
Remplacer les &quot;IN&quot; par des jointures, ou la sous-requête par une deuxième dont le résultat est stockée dans une table temporaire.

=== Too many tables (ou timeouts systématiques) ===
Si des requêtes sont systématiquement en timeout, c'est peut-être que la limite de 61 jointures a été atteinte.
Pour pallier cela, il est possible d'en remplacer certaines par des SELECT&lt;ref&gt;https://www.quora.com/How-do-I-override-a-max-limit-of-61-joins-in-a-MySQL-query&lt;/ref&gt;.

=== Type d'énoncé non reconnu ===
Certains mots clés ne sont reconnus que dans les procédures stockées, ou doivent être précédés d'un SELECT.

=== Unexpected end of JSON text in argument 1 to function 'json_extract' ===
Lever l'exception vide avec : &lt;code&gt;if(x = &quot;&quot;, null, json_extract(x, y))&lt;/code&gt;.

=== Unknown storage engine 'federated' mariadb ===
Lancer &quot;mysql&quot; en shell puis taper :
 install plugin federated soname 'ha_federated.so';

=== You can't specify target table '...' for update in FROM clause ===
Cela se produit quand on essaie de mettre à jour ou supprimer des lignes selon une sélection de ces mêmes lignes. En effet, il est impossible de mettre à jour une table pendant en même temps qu'elle une subit sous-requête. Par exemple, pour réinitialiser un mot de passe {{w|Système de publication pour l'Internet|SPIP}} :
 mysql&gt; UPDATE spip_auteurs SET pass =
  (SELECT pass FROM spip_auteurs WHERE login='paul') where login='admin';
 ERROR 1093 (HY000): You can't specify target table 'spip_auteurs' for update in FROM clause

* Passer par des &lt;code&gt;CREATE TEMPORARY TABLE&lt;/code&gt; (voire &lt;code&gt;DECLARE&lt;/code&gt; si cela rentre dans une {{wt|variable scalaire}}).
* Sinon, il est possible de sélectionner les enregistrements à mettre à jour automatiquement en enveloppant la sous-requête dans une autre, grâce aux tables temporaires générées par les &lt;code&gt;FROM&lt;/code&gt;&lt;ref&gt;({{en}}) http://www.xaprb.com/blog/2006/06/23/how-to-select-from-an-update-target-in-mysql/&lt;/ref&gt;.

=== You do not have the SUPER privilege and binary logging is enabled ===
 SET GLOBAL log_bin_trust_function_creators = 1;

== phpMyAdmin ==
=== Erreur : fonctionnalités relationnelles désactivées ! ===
Se produit dans le concepteur de diagramme de phpMyAdmin, il faut l'activer dans &lt;u&gt;config.inc.php&lt;/u&gt;.

== Références ==
{{Références}}

&lt;noinclude&gt;[[Catégorie:Messages d'erreur]]&lt;/noinclude&gt;</text>
      <sha1>2fxlxcl24427wkkel5w0l8fotmijqpa</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/B/Henry Peter Bosse</title>
    <ns>0</ns>
    <id>67982</id>
    <revision>
      <id>684269</id>
      <parentid>535684</parentid>
      <timestamp>2022-08-27T18:12:02Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6591" xml:space="preserve">{{Ph s Personnalités}}


[[File:HP Bosse.jpg|thumb|240px|Portrait de Henry Peter Bosse à Rock Island, Illinois, vers 1900 ; remerciements à William Quaintance, Moline IL.]]                                           
[[File:HP Bosse selfportrait.jpg|thumb|240px|Autoportrait en caricature par Henry Peter Bosse vers 1890.]]

Cet article est adapté de son homologue de la Wikipédia en langue anglaise.


'''Henry Peter Bosse''' était un cartographe, ingénieur civil et photographe germano-états-unien.

== Biographie ==

Henry Peter Bosse est né le 13 novembre 1844 à Sonnendorf en Saxe prussienne, où il passa son enfance. On ne sait pas grand chose de sa jeunesse et de son éducation en Allemagne, sauf qu'il avait un lien familial avec [[w:Abraham Bosse|Abraham Bosse]] (1620 – 1676), le fameux graveur et théoricien de la topographie. Henry Peter Bosse affirmait être le petit-fils du comte [[w:en:August Neidhardt von Gneisenau|August Neidhardt von Gneisenau]]

En 1870 Henry Peter Bosse émigra à Chicago, aux États-Unis. Il trouva un premier emploi dans la papeterie. Dans les années 1880 il fut embauché comme dessinateur et cartographe dans l'armée états-unienne à Rock Island, Illinois. De 1882 à 1892 il photographia le Haut-Mississipi et se passionna pour cette region.

En 1893, Henry Peter Bosse publia un livre de grand format, ''Views on the Mississippi River between Minneapolis, Minn and St. Louis, Mo. 1883–1891'', illustré de [[cyanotype]]s bleus très soignés. Un de exemplaire vint entre les mains d'Alexander Mackenzie, Chef du Corps des Ingénieurs militaires, chacun des 169 cyanotypes a été tiré en utilisant un cache ovale, et tous ont été accompagnés d'un titre écrit à l'encre par Bosse.

En 1894-94, le livre d'Henry Peter Bosse ''Views on the Mississippi River between Minneapolis, Minn and St. Louis, Mo. 1883–1891'' a été exposé lors de la ''[[w:en:World Columbian Exposition|World Columbian Exposition of 1893]]'' à Chicago, marquant un tournant dans l'histoire de la photographie.

== Un travail d'artiste ==

Henry Peter Bosse fut un un photographe précurseur en ce qu'il avait vu loin et adhéré aux valeurs esthétiques qui avaient défini les travail des photo-journalistes allemandes dans le monde entier. Une composition rigoureuse et un intérêt pour l'effort humain caractérisent le regard photographique de Bosse, devenant la base du photo-reportage. Bosse prenait le plus grand soin de la présentation de ses albums. Il anticipa le besoin de la couleur : l'ambiance bleu intense de ses cyanotypes raffinés reflète cette préoccupation. Ses cyanotypes étaient exposés sous de larges feuilles de verre et tirés sur le meilleur papier français, chacune des feuilles de 37 x 44 cm portant le filigrane ''Johannot et Cie. Annonay, aloe's satin''. Les albums étaient reliés en cuir. Au-delà de la technique, par son intérêt pour les ponts ferroviaires et les constructions en acier, Bosse était au sommet de la réputation allemande pour les livres illustrant le travail de l'homme, l'architecture moder,ne et 

Au-delà de la technique, dans son appréciation pour des ponts de chemin de fer et l'acier de construction, Bosse a été debout au premier rang d'appréciation allemande pour photographique &quot;des livres de regard(d'apparence)&quot; concerné(préoccupé) de la main d'homme, l'architecture moderne et l'urbanisme.

&lt;gallery widths=&quot;240px&quot; heights=&quot;240px&quot;&gt;
CBandQ RR Bridge Burlington Iowa 1891.jpg
Fort Snelling Minnesota from bar opposite 1889.jpg
Henry Peter Bosse grave.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-01.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-02.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-03.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-04.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-05.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-06.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-07.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-08.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-09.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-10.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-11.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-12.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-13.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-14.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-15.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-16.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-17.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-18.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-19.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-20.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-21.jpg
Henry-Peter-Bosse-Cyanotype-Mississippi-22.jpg
Iowa Central RR Bridge Keithsberg Illinois 1889.jpg
Major Alexander Mackenzie by Bosse.jpg
Mouth St Croix Railroad.jpg
Smith Avenue Bridge St Paul Minnesota.jpg
&lt;/gallery&gt;

== Un ingénieur et cartographe ==

Henry Peter Bosse fut à son époque un des techniciens les mieux pays aux États-Unis.

Les années 1880 ont marqué le début de la construction d'immeubles à structure métallique et de ponts suspendus comme le pont de Brooklyn construit par [[w:en:Röbling|Röbling]] en 1883. À cette époque Bosse était un ingénieur en chef à l'endroit où les compagnies de chemins de fer voulaient traverser le très large Mississipi. La photographie a aidé Bosse à créer la carte la plus précise jamais faite du Haut-Mississipi, ce qui en retour a facilité la conception des ponts, des tranchées et des remblais. Plusieurs variantes de cette carte existent, tandis que son album de photographies, par lui-même, était déjà la première cartographie photographique d'une rivière importante jamais réalisée.

== Œuvres de Bosse dans les collections publique ==

Depuis que l'album de cyanotypes de Bosse appartenant à Alexander Makenzie à refait surface dans une vente aux enchères chez Sotheby en 1990, les cyanotypes font partie des collections permanentes du [[w:en:J. Paul Getty Museum|J. Paul Getty Museum]] à Los Angeles.

Le ''[[San Francisco Museum of Modern Art]]'' en Californie, le ''[[Metropolitan Museum of Art]]'' de New York, le ''[[Amon Carter Museum of Art]]'' au Texas, le ''[[Nelson-Atkins Museum of Art]]'' à Kansas City, le ''[[National Museum of American Art]]'' à Washington, le ''[[Minneapolis Institute of Arts]]'' du Minnesota et d'autres Institutions possèdent des photographies de Bosse.

== Un inventaire ==

Un inventaire approfondi des œuvres connues de Bosse a été réalisé par Bob Wiederanders du ''[[Fred W. Woodward Riverboat Museum]]'', Dubuque, Iowa.


{{Ph Personnalités}}

{{DEFAULTSORT:Bosse, Henry Peter}}</text>
      <sha1>ngtkxezffgwjvw0p8bwbricpxhimlyc</sha1>
    </revision>
  </page>
  <page>
    <title>Recettes de villages qui bougent/Recettes de projets/Gratiferia</title>
    <ns>0</ns>
    <id>68791</id>
    <revision>
      <id>684311</id>
      <parentid>672642</parentid>
      <timestamp>2022-08-27T18:48:26Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5522" xml:space="preserve">=Gratiferia=
Une foire où tous les objets sont donnés plutôt que vendus.
==Présentation générale==
''Une gratiferia se déroule comme une foire ouverte au public où des objets qui ne servent plus à leur propriétaire sont proposés sur des stands (livres, CD, vêtements…). Chacun peut prendre librement les objets qui lui plaisent.''

* durée de mise en place : 🕙
* facilité de mise en œuvre : 🔨
* Mots clés : don, gratuité

===Pourquoi se lancer dans ce projet ?=== 
Dans notre société, nous sommes plus habitués à l’échange ou à la vente. Le don pourtant permet de maximiser la “valeur d’usage” : ce qui n’est pas ou plus important pour l’un peut l’être pour un autre. C’est également le moyen de créer du lien et d’échanger avec des passants surpris par la gratuité. 
===Licence Creative Commons cc-by-sa 4.0.===
Vous pouvez partager, copier, modifier librement cette recette à condition de citer la source “Recettes de projets” et de fournir la version modifiée avec la même licence.
==Mieux comprendre la gratiferia==
===L’origine du projet :===
La gratiferia “fête du gratuit” est une idée toute simple lancée en 2010 par l’argentin Ariel Rodriguez Bosio, qui s’est ensuite répandue dans le monde entier.
===Ce que vit un utilisateur===
Tout comme dans un vide grenier, le visiteur passe de stands en stands, regarde, fouille. Mais lorsqu’il trouve quelque chose qui l’intéresse, il lui suffit de le prendre ! Un panneau et/ou une personne peuvent lui expliquer le principe et surtout l’encourager à prendre même si il n’a rien apporté à donner. Il peut également recevoir gratuitement un ou plusieurs services sur place (cours, assistance…) ou plus tard.
===Succès===
[à compléter]
===Freins - difficultés===
* Il faut souvent expliquer aux participants qu’ils peuvent prendre sans rien en retour  (il est parfois plus difficile de recevoir que de donner dans notre culture…).
* A l’inverse dans de très rares cas, on peut avoir une personne qui prend le maximum de choses. Le fait d’être visible de tous rend ce type de comportement moins fréquent, mais si cela arrive, il suffit de demander à la personne de prendre ce qui lui plaît le plus et de laisser le reste pour que les autres puissent en profiter aussi.
==Mettre en œuvre une gratiferia ou s’en inspirer ?==
===La recette pour les pressés===
À quelques uns, rassemblez des objets qui ne vous servent plus (livres, CD voire vêtements, vélos d’enfants…). Invitez du monde le jour J ou insérez-vous dans un événement existants et posez le tout sur une table avec un écriteaux “servez-vous, c’est gratuit”
===À faire avant===
# Choisissez quand et où vous allez organiser votre gratiféria : lors d’un événement existants où vous pourrez avoir un stand (fête, marché, journée des associations…) ou bien décidez d’organiser votre propre événement (en contactant la Mairie si cela se passe sur l’espace public)
# Quelques jours avant, demandez à quelques amis d’apporter des objets qu’ils n’utilisent plus et qu’ils souhaitent donner. Vous serez surpris probablement par le nombre d’objets apportés. L’apport des objets peut aussi être un moment festif. Pourquoi par exemple ne pas organiser un repas entre amis ou avec votre groupe au cours du quel chacun pourra apporter ses objets
# Profitez en pour identifier quelques services qui pourraient être offerts par certains soit sur place soit plus tard (du cours de guitare à l’assistance juridique, le choix est vaste !)
# Préparez un ou plusieurs panneaux avec un texte tel que :
{| class=&quot;wikitable&quot;
|-
| Servez-vous ! 
Ceci est une “gratiféria”, 
Un marché gratuit ou on peut donner et prendre des objets ou proposer des services gratuits… dans la seule limite du raisonnable.
Une idée lancée en 2010 par l’argentin Ariel Rodriguez Bosio, qui s’est ensuite répandue dans le monde entier
|}
Le fait de présenter brièvement l’origine montre que ce n’est pas une idée folle isolée
Le fait d’indiquer la “limite du raisonnable” à l’avance, facilite la gestion des prises d’objets “irraisonnables” si elles arrivent. 
===À faire pendant===
# Installez les tables, les objets sur les tables (si vous en avez beaucoup ne sortez pas tout pour réapprovisionner progressivement), installez les panneaux et restez autour pour discuter avec chacun. C’est tout !
===À faire après===
# Chacun peut reprendre les objets qu’il a apporté et qui ne sont pas partis ou si vous pouvez les stocker, conservez-les pour une prochaine gratiferia !
==Retours d’expérience==
===Saulieu Demain===
La communauté [http://coop-group.org/Saulieu/ Saulieu Demain], venait de naître quelques mois plus tôt. Les participants sont pour la grande majorité peu militants (des habitants, des commerçants, des producteurs locaux). Nous avions fait des premières actions “entre nous” comme des échanges de graines. La première gratiferia a été une excellente première étape pour “oser” faire des actions pour tous…
==Pour aller plus loin==
===Pour ne pas rester seul=== 
* Bibliographie, webographie : 
* Quelques ressources pratiques : 
* Commentaires de ceux qui ont testés la recette : 
* Passer à l‘échelle : dans le même esprit, vous pouvez installer une boîte à don (plus permanente) ou montrer à tous l’ampleur des dons grâce à la donnaie.

[[Catégorie:Recettes_de_projet|{{SUBPAGENAME}}]]</text>
      <sha1>awshom2i9r4qd91i1qq8wn2fg64p9u2</sha1>
    </revision>
  </page>
  <page>
    <title>Précis d'épistémologie/Références</title>
    <ns>0</ns>
    <id>68802</id>
    <revision>
      <id>684266</id>
      <parentid>657973</parentid>
      <timestamp>2022-08-27T18:08:01Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8963" xml:space="preserve">&lt;noinclude&gt;{{Précis d'épistémologie}}&lt;/noinclude&gt;
Aristote, ''Ethique à Nicomaque'', ''Organon'', ''Les parties des animaux'', ''De l'âme'', ''Physique'', ''Métaphysique''

Baars, Bernard J., ''A cognitive theory of consciousness'' (1988)

Beck, Aaron T., ''La thérapie cognitive et les troubles émotionnels'' (1975)

Benaceraff, Paul, ''Mathematical Truth'' (1973, Journal of Philosophy 70, 661–80, reproduced in P. Benaceraff and H. Putnam (eds.), ''Philosophy of Mathematics: Selected Readings'' 1983).

Berthoz, Alain, ''Le sens du mouvement'' (1997)

Bird, Alexander, ''Nature's Metaphysics: Laws and Properties'' (2007)

Borges, Rodrigo, de Almeida, Claudio and Klein, Peter D., ''Explaining knowledge: new essays on the Gettier problem'' (2017)

Carroll, Lewis, ''What the Tortoise Said to Achilles'' (1895)

Chalmers, David J., ''The conscious mind'' (1996)

Changeux, Jean-Pierre, ''L'homme de vérité'' (2002)

Cohen, Paul J., ''Set theory and the continuum hypothesis'' (1966)

Cottraux, Jean, ''La répétition des scénarios de vie'' (2001)

Churchland, Patricia S. &amp; Sejnowski, Terrence J., ''The computational brain'' (1992)

Condorcet, Nicolas de, ''Essai sur l’application de l’analyse à la probabilité des décisions rendues à la pluralité des voix'' (1785) 

Damasio, Antonio, ''Time-locked multiregional retroactivation: A systems-level proposal for the neural substrates of recall and recognition'' (1989, Cognition, 33, 25-62), ''L'erreur de Descartes'' (1994), ''Convergence and divergence in a neural architecture for recognition and memory'' (avec Kaspar Meyer, 2009, Trends in NeuBorges, Rodrigo, de Almeida, Claudio and Klein, Peter D., ''Explaining knowledge: new essays on the Gettier problem'' (2017)
rosciences Vol.32 No.7, 376-382)

Darwin, Charles, ''L'origine des espèces'' (1859)

Dawkins, Richard, ''Climbing Mount Improbable'' (1997)

Dedekind, Richard, ''Was sind und was sollen die Zahlen?'' (1888)

Dehaene, Stanislas, ''Le code de la conscience'' (2014)

Depaul, Michael R., ''Intuitions in moral inquiry'' (2006, dans ''The Oxford handbook of ethical theory'')

Descartes, René, ''Le Discours de la méthode pour bien conduire sa raison et chercher la vérité dans les sciences'' (1637)

Dieterle, Jill Marie, [https://etd.ohiolink.edu/pg_10?0::NO:10:P10_ACCESSION_NUM:osu1392052320 ''Structure and object ''] (1994)

Dretske, Fred, ''Conclusive reasons'' (1971, ''The Australian Journal of Philosophy'', 49, reproduced in Dretske &amp; Bernecker 2000)

Dretske, Fred and Bernecker Sven, ''Knowledge, readings in contemporary epistemology'' (2000) 

Dugnolle, Thierry, ''[[Théorie quantique de l'observation]]'' (2018)

Einstein, Albert, ''La théorie de la relativité restreinte et générale'' (1916)

Fine, Gail, ''The possibility of inquiry, Meno's paradox from Socrates to Sextus'' (2014)

Fitch, Frederic Brenton, ''Symbolic logic, an introduction'' (1952)

Fraenkel, Abraham, ''Abstract set theory'' (1953) 

Freud, Sigmund, ''Introduction à la psychanalyse'' (1915), ''Le moi et le ça'' (1923)

Gazzaniga, Michael S., ''The mind's past'' (1998), ''Neurosciences cognitives : la biologie de l'esprit'' (2001, avec Richard B. Ivry)

Gentzen, Gerhard, ''Recherches sur la déduction logique'' (1934)

Gettier, Edmund L., ''Is justified true belief knowledge?'' (1963, ''Analysis'', 23, reproduced in Dretske et Bernecker 2000)

Gödel Kurt, ''Sur la complétude du calcul logique'' (1929, Thèse de doctorat)

Goldman, Alvin, ''Epistemology and Cognition'' (1986), ''Knowledge in a Social World'' (1999), ''Simulating Minds, the philosophy, psychology, and neuroscience of mindreading'' (2006)

Goodman, Nelson, ''Faits, fictions et prédictions'' (1955) 

Gould, James L. &amp; Gould, Carol Grant, ''The animal mind'' (1994)

Greenberg, Leslie S., Angus, Lynne E., ''Working with narratives in emotion-focused therapy: changing stories, healing lives'' (2011)

Hebb, Donald, ''The organization of behavior'' (1949)

Hegel, Georg Wilhelm Friedrich, ''Propédeutique philosophique'' , ''La philosophie de l'esprit'' (1830)

Hofstadter, Douglas, ''Fluid concepts and creative analogies'' (1995, avec the Fluid Analogies Research Group), ''Je suis une boucle étrange'' (2007), ''L'analogie, cœur de la pensée'' (2013, avec Emmanuel Sander)  

Hursthouse, Rosalind, ''On virtue ethics'' (2001)

Irwin, Terence, ''The development of ethics'' (I:2007, II:2008, III:2009)

James, William, ''The principles of psychology'' (1890)

Kandel, Eric R. &amp; Squire, Larry R., ''La mémoire : de l'esprit aux molécules'' (1999)

Kant, Emmanuel, ''Critique de la raison pure'' (1781, 1787), ''Fondements de la métaphysique des mœurs'' (1785)

Kauffman, Stuart, ''The origins of order'' (1993), ''At home in the universe'' (1995)

Keisler, H. Jerome, ''Fundamentals of Model Theory'' (1977, dans ''Handbook of mathematical logic'', édité par Jon Barwise)

Kripke, Saul, ''La logique des noms propres'' (1972, traduit de ''Naming and necessity'')

Lachaux, Jean-Philippe, ''Le cerveau attentif : contrôle, maîtrise et lâcher-prise'' (2011)

Laing, Ronald D., ''Le moi divisé'' (1959)

Ledoux, Joseph E., ''Le cerveau des émotions'' (1996), ''Neurobiologie de la personnalité'' (2002)

Leibniz, Gottfried Wilhelm, ''Discours touchant la méthode de la certitude et l’art d’inventer pour finir les disputes et faire en peu de temps de grands progrès'' (1688-1690), ''Nouveaux essais sur l'entendement humain'' (1705)

Lewis, David, ''Sur la pluralité des mondes'' (1986)

Locke, John, ''Essai sur l'entendement humain'' (1690) 

Lorenz, Konrad, ''Les fondements de l'éthologie'' (1981) 

Maruna, Shadd, ''Making good: how ex-convicts reform and rebuild their lives'' (2008)

Maslow, Abraham, ''Devenir le meilleur de soi-même : besoins fondamentaux, motivation et personnalité'' (1954)

Minsky, Marvin, ''La société de l'esprit'' (1987), ''The emotion machine'' (2006)

Newell, Allen &amp; Simon, Herbert A., ''Human problem solving'' (1972)

Pascal, Blaise, ''De l’esprit géométrique et de l’art de persuader'' (1657)

Peacocke, Christopher, ''Being known'' (1999)

Plantinga, Alvin, ''Warrant and proper function'' (1993)

Platon, ''Ménon'', ''Le banquet'', ''Théétète'', ''Le sophiste'', ''Parménide''

Popper, Karl R., ''La logique de la découverte scientifique'' (1934)

Proust, Marcel, ''Le temps retrouvé'' (1927)

Quine, Willard Van Orman, ''La poursuite de la vérité'' (1992)

Rawls, John, ''Théorie de la justice'' (1971)

Rizzolatti, Giacomo &amp; Sinigaglia, Corrado, ''Les neurones miroirs'' (2006) 

Rogers, Carl R., ''Client-centered therapy'' (1951, traduit dans ''Psychothérapie et relations humaines'')

Rumelhart, David E., McClelland James L. &amp; the PDP Research Group, ''Parallel distributed processing, Explorations in the microstructure of cognition, 1 : Foundations, 2 : Psychological and biological models'' (1986)

Russell, Bertrand, ''Les principes des mathématiques'' (1903, partiellement traduit dans ''Écrits de logique philosophique'')

Russell, Stuart &amp; Norvig, Peter, ''Artificial intelligence, a modern approach'' (2010)

Saussure, Ferdinand de, ''Cours de linguistique générale'' (1916)

Sextus Empiricus, ''Contre les professeurs'', ''Esquisses pyrrhoniennes'' 

Shallice, Tim, ''From neuropsychology to mental structure'' (1988), ''The organisation of mind'' (2011, avec Richard P. Cooper)

Shapiro, Stewart, ''Philosophy of Mathematics: Structure and Ontology'' (1997), ''Thinking about Mathematics: The Philosophy of Mathematics'' (2000)

Shoemaker, Sidney, ''Causality and properties'' (1980, in Peter van Inwagen (ed.), ''Time and Cause'')

Smith, John Maynard, Szathmary, Eörs, ''Les origines de la vie'' (1999)

Smullyan, Raymond M., ''Theory of formal systems'' (1961)

Spinoza, Baruch, ''Éthique'' (1677) 

Tarski, Alfred, ''Le concept de vérité dans les langages formalisés'' (1933, édité dans ''Logique, sémantique, métamathématique'')

Thorne, Kip S., Blandford, Roger D., ''Modern classical physics'' (2017)

Tinbergen, Nikolaas, ''L'étude de l'instinct'' (1951)

Turing, Alan, ''On computable numbers'' (1936), ''Computing machinery and intelligence'' (1950, Mind,  vol. 59, n°236)

Voltaire, ''Candide'' (1759)

Weber, Max, ''Essais sur la théorie de la science'' (1904-1917)

White, Michael, Epston, David, ''Narrative means to therapeutic ends'' (1990)

Wigner, Eugene P., ''The unreasonable effectiveness of mathematics in the natural sciences'' (1960, Comm. Pure Appl. Math., 13).
   
Wittgenstein, Ludwig, ''Recherches philosophiques'' (1953)

Wolpert, Lewis, Tickle, Cheryll &amp; Martinez Arias, Alfonso, ''Principles of development'' (2015)

Young, Jeffrey E., Klosko, Janet S., ''La thérapie des schémas'' (2003, avec Marjorie E. Weishaar)

Zagzebski, Linda, ''The lesson of Gettier'' (in Borges, de Almeida &amp; Klein 2017)

Zermelo, Ernst, ''Investigations in the foundations of set theory'' (1908)

{{Autocat}}</text>
      <sha1>cy5pj4vy3ej0e8yambd5kbhsn9237du</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation Python/Tableau des opérateurs</title>
    <ns>0</ns>
    <id>68972</id>
    <revision>
      <id>684242</id>
      <parentid>663838</parentid>
      <timestamp>2022-08-27T12:55:42Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6027" xml:space="preserve">&lt;noinclude&gt;{{Python}}&lt;/noinclude&gt;

== Priorité des opérations ==
Lorsqu'il y a plus d'un opérateur dans une expression, l'ordre dans lequel les opérations doivent être effectuées dépend de ''règles de priorité''. Sous Python, les règles de priorité sont les mêmes que celles qui vous ont été enseignées au cours de mathématique. Vous pouvez les mémoriser aisément à l'aide d'un « truc » mnémotechnique, l'acronyme &lt;code&gt;PEMDAS&lt;/code&gt; :

* &lt;code&gt;P&lt;/code&gt; pour ''parenthèses''. Ce sont elles qui ont la plus haute priorité. Elles vous permettent donc de « forcer » l'évaluation d'une expression dans l'ordre que vous voulez.&lt;br /&gt;Ainsi &lt;code&gt;2*(3-1) = 4&lt;/code&gt;, et &lt;code&gt;(1+1)**(5-2) = 8&lt;/code&gt;.

* &lt;code&gt;E&lt;/code&gt; pour ''exposants''. Les exposants sont évalués ensuite, avant les autres opérations.&lt;br /&gt; Ainsi &lt;code&gt;2**1+1 = 3&lt;/code&gt; (et non 4),  et  &lt;code&gt;3*1**10 = 3&lt;/code&gt; (et non 59049 !).

* &lt;code&gt;M&lt;/code&gt; et &lt;code&gt;D&lt;/code&gt; pour ''multiplication'' et ''division'', qui ont la même priorité. Elles sont évaluées avant l'''addition'' &lt;code&gt;A&lt;/code&gt; et la ''soustraction'' &lt;code&gt;S&lt;/code&gt;, lesquelles sont donc effectuées en dernier lieu. &lt;br /&gt;Ainsi &lt;code&gt;2-2*2 renvoie -2 et non 0 !&lt;/code&gt;Et  &lt;code&gt;2+4/2 renvoie 4.0 et non 3.0&lt;/code&gt; (Rappelez-vous que / est l'opérateur de la division décimale). &lt;br /&gt;Si deux opérateurs ont la même priorité, l'évaluation est effectuée de gauche à droite. &lt;br /&gt;Ainsi dans l'expression &lt;code&gt;59*100/60&lt;/code&gt;, la multiplication est effectuée en premier, et la machine doit donc ensuite effectuer &lt;code&gt;5900/60&lt;/code&gt;, ce qui donne &lt;code&gt;98.0&lt;/code&gt;.

* &lt;code&gt;A&lt;/code&gt; et &lt;code&gt;S&lt;/code&gt; pour ''addition'' et ''soustraction''.

Dans le tableau ci-dessous :
* les opérateurs regroupés entre deux lignes épaisses ont la même priorité.
* le sens d'évaluation indique l'ordre d'évaluation des opérations dans une expression :
** &amp;rarr; pour une évaluation de gauche à droite : a OP1 b OP2 c == (a OP1 b) OP2 c ;
** &amp;larr; pour une évaluation de droite à gauche : a OP1 b OP2 c == a OP1 (b OP2 c).
* le type peut être :
** « groupe » pour un couple de caractères encadrant une ou plusieurs expressions,
** « binaire » pour un opérateur situé entre ses deux opérandes,
** « ternaire » pour un opérateur utilisant trois opérandes,
** « unaire » pour un opérateur précédant son unique opérande.

{| class=&quot;wikitable altlines1&quot;
|+ Précédence des opérateurs du plus au moins prioritaire&lt;ref&gt;https://docs.python.org/fr/3.6/reference/expressions.html#operator-precedence&lt;/ref&gt;
|-
! Symbole !! Type !! Évaluation !! Nom
|- style=&quot;border-top:solid 4px;&quot;
| {} || Groupe || || Agencement de dictionnaire
|-
| () || Groupe || || Agencement de n-uplet
|-
| [] || Groupe || || Agencement de liste
|- style=&quot;border-top:solid 4px;&quot;
| . || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Attribut
|-
| () || Groupe || || Argument de fonction
|-
| [] || Groupe || || Partie (opérateur d'indiçage)
|- style=&quot;border-top:solid 4px;&quot;
| await || Unaire || style=&quot;text-align:center;&quot; | &amp;larr; || Attente de résultat
|- style=&quot;border-top:solid 4px;&quot;
| ** || Binaire || style=&quot;text-align:center;&quot; | &amp;larr; || Puissance
|- style=&quot;border-top:solid 4px;&quot;
| ~ || Unaire || style=&quot;text-align:center;&quot; | &amp;larr; || inversion de bit
|-
| + || Unaire || style=&quot;text-align:center;&quot; | &amp;larr; || Positif
|-
| - || Unaire || style=&quot;text-align:center;&quot; | &amp;larr; || Négatif
|- style=&quot;border-top:solid 4px;&quot;
| * || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Multiplier
|-
| @ || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Multiplication de matrices
|-
| / || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Diviser
|-
| // || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Résultat entier d'une division
|-
| % || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Modulo
|- style=&quot;border-top:solid 4px;&quot;
| + || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Addition
|-
| - || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Soustraction
|- style=&quot;border-top:solid 4px;&quot;
| &lt;&lt; || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Décalage à gauche
|-
| &gt;&gt; || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Décalage à droite
|- style=&quot;border-top:solid 4px;&quot;
| &amp; || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || {{wt|et logique}}
|- style=&quot;border-top:solid 4px;&quot;
| ^ || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || {{wt|ou exclusif}}
|- style=&quot;border-top:solid 4px;&quot;
| &lt;nowiki&gt;|&lt;/nowiki&gt; || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || {{wt|ou logique}}
|- style=&quot;border-top:solid 4px;&quot;
| in || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Test d'appartenance
|-
| not in || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Test de non appartenance
|-
| is || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Test d'égalité type
|-
| is not || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || Test de non égalité de type
|-
| &lt; || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || inférieur
|-
| &gt; || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || supérieur
|-
| &lt;= || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || inférieur ou égal
|-
| &gt;= || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || supérieur ou égal
|-
| == || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || est égal
|-
| != || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || est différent
|- style=&quot;border-top:solid 4px;&quot;
| not || Unaire || style=&quot;text-align:center;&quot; | &amp;larr; || non booléen
|- style=&quot;border-top:solid 4px;&quot;
| and || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || et booléen
|- style=&quot;border-top:solid 4px;&quot;
| or || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || ou booléen
|- style=&quot;border-top:solid 4px;&quot;
| if ... else ... || Ternaire || style=&quot;text-align:center;&quot; | &amp;rarr; || expression conditionnelle
|- style=&quot;border-top:solid 4px;&quot;
| lambda || Binaire || style=&quot;text-align:center;&quot; | &amp;rarr; || {{wt|expression lambda}}
|}
&lt;noinclude&gt;
== Références ==
{{Références}}
&lt;/noinclude&gt;</text>
      <sha1>6e8alyf6ljsargttsiivydy3hxu4cch</sha1>
    </revision>
  </page>
  <page>
    <title>Hélice/Sommaire global du livre</title>
    <ns>0</ns>
    <id>69313</id>
    <revision>
      <id>684301</id>
      <parentid>565506</parentid>
      <timestamp>2022-08-27T18:34:49Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3048" xml:space="preserve">&lt;!--; Avant propos : {{Cacher à l'impression|'''''Imprimer au format livret à 120%. La couverture peut être imprimée séparément sans bordure'''''.}} &lt;br/--&gt;
[[File:Livres concernant l'hélice marine.jpg|200px|right]]


Cette version imprimable ''L'hélice Marine &lt;small&gt;Théorie et application&lt;/small&gt;'' est un recueil d'articles et de pages publiés sur wiki-livre entre les années 2006 et 2016. Les redites ont été évitées mais sous ce titre commun vous trouverez des parties inévitablement semblables. Des versions complètes de chacun de ces articles sont disponibles sur wiki-livres.
&lt;!--
* Le livre complet ''Hélice'' a été publié avec l'aide de PEDIAPRESS sous le nom ''L'hélice marine &lt;small&gt;et la thermodynamique&lt;/small&gt;''. 

* L'article complet ''Hélices de navires à déplacement'' a été publié au format PDF&lt;ref&gt;&lt;small&gt;https://upload.wikimedia.org/wikipedia/commons/f/fc/Hélices_de_navires_à_déplacement-fr.pdf&lt;/small&gt;&lt;/ref&gt; 
--&gt;

{| 
|----
!! scope=&quot;col&quot; style=&quot;text-align:left;&quot;|Contenu
!! scope=&quot;col&quot; style=&quot;text-align:right;&quot;|Page
|----&gt;
| &amp;nbsp; [[Hélice/Préambule|Préambule ]] 
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 3
|----
| &amp;nbsp; [[Discussion:Hélice]]
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 5
|----
!! scope=&quot;col&quot; style=&quot;text-align:left;&quot;|Recueil d'articles des wiki-livres suivants :

|----
| &amp;nbsp; [[Hélice]]. &lt;small&gt;Selon les théories de Isaac Newton et le point de vue thermodynamique.&lt;/small&gt;
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 10
|----
| &amp;nbsp; [[Hélices de navires à déplacement]]. &lt;small&gt;Application de la théorie.&lt;/small&gt;
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 22
|----
!! scope=&quot;col&quot; style=&quot;text-align:left;&quot;| Annexes

|----
| &amp;nbsp; QR-Codes pour télécharger les feuilles de calcul et autres liens pour smartphones.
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 51
|----
| &amp;nbsp; Sources, contributeurs et licences du texte et des images
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 53
|----
!! scope=&quot;col&quot; style=&quot;text-align:left;&quot;| Liens vers des articles complémentaires :&lt;small&gt;{{bleu|''Éditer les articles ci-dessous pour les lire ou les imprimer''}}&lt;/small&gt;

|----
| &amp;nbsp; [[Hélices_de_navires_à_déplacement/Images grand format|Images grand format (A4 paysage)]] &lt;ref&gt;&lt;small&gt;''https://fr.wikibooks.org/wiki/Hélices_de_navires_à_déplacement/Images_grand_format''&lt;/small&gt;&lt;/ref&gt;
|----
| &amp;nbsp; [[Hélices_de_navires_à_déplacement/Compilations_wikilivres|Aide pour la Compilations des wikilivres]]&lt;ref&gt;&lt;small&gt;{{bleu|''https://fr.wikibooks.org/wiki/Hélices_de_navires_à_déplacement/Compilations_wikilivres''}}&lt;/small&gt;&lt;/ref&gt;
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 
|----
| &amp;nbsp; [[Hélices_de_navires_à_déplacement/Version_imprimable#Licence_de_documentation_libre_GNU|Licence de documentation libre GNU]]&lt;ref&gt;&lt;small&gt;''https://fr.wikibooks.org/wiki/Hélices_de_navires_à_déplacement/Version_imprimable#Licence_de_documentation_libre_GNU''&lt;/small&gt;&lt;/ref&gt;
| colspan=&quot;2&quot; style=&quot;text-align:right;&quot;| 
|}
; Liens :
&lt;references /&gt;

[[Catégorie:Hélice (livre)]]</text>
      <sha1>373f4rlor76fqdco6dftndgy4gy8f41</sha1>
    </revision>
  </page>
  <page>
    <title>Planétologie/La géologie de la Lune</title>
    <ns>0</ns>
    <id>69608</id>
    <revision>
      <id>684250</id>
      <parentid>677674</parentid>
      <timestamp>2022-08-27T14:47:33Z</timestamp>
      <contributor>
        <username>Romanc19s</username>
        <id>3047</id>
      </contributor>
      <comment>Orthographe &quot;ont subIII&quot;/* La surface de la Lune : mers et terres lunaires */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40574" xml:space="preserve">[[File:Moon rotating full 220px.gif|vignette|Gif animé de la Lune.]]

La lune est un astre visible depuis la Terre, rendant son observation aisée : pas besoin d'envoyer des sondes spatiales pour voir sa surface. Du moins, pour ce qui est de voir la face visible depuis la Terre. En conséquence, la surface de la Lune est relativement bien connue, et sa géologie l'est tout autant. D'autres méthodes permettent d'obtenir des informations sur notre satellite :

* l'étude des séismes avec les sismomètres laissés par les missions de la NASA ;
* l'évaluation de la densité de la Lune et de sa rotation ;
* l'étude des météorites lunaires et de leur composition chimique ;
* l'étude des échantillons de roche prélevés par les missions Apollo ;
* l'étude du champ gravitationnel de la Lune avec des satellites en orbite ;
* l'étude de la topographie de la surface, au télescope ou avec des satellites.

Ces données ont été utilisées par les planétologues pour étudier la géologie de la Lune. Nous vous proposons de voir ce que les géologues ont découvert.

==La surface de la Lune : mers et terres lunaires==

[[File:Moon Sketch vector.svg|vignette|upright=1.0|Apparence de la Lune.]]

L'observation de la croûte montre qu'il n'y a pas de tectonique des plaques, et qu'il n'y en a jamais eu : on n'observe pas de fosses de subductions, de rifts, de dorsales, ou de structures tectoniques de grande taille. Pour autant, la surface de la lune n'est pas homogène. L'observation montre qu'elle est formée de terrains clairs et sombres. Les zones claires sont appelées des ''terraes'', des continents, ou encore les '''terres lunaires''', alors que les zones sombres sont appelées des '''mers lunaires'''. La différence de couleur entre terres et mers provient de différences de composition chimique et minéralogique. Les continents lunaires sont composés principalement d'anorthosite, un minéral très courant dans les roches magmatiques granitiques, qui leur donne leur couleur claire, grise. Les mers lunaires sont composées essentiellement de basaltes, des roches volcaniques pauvres en silice. Vu que les basaltes sont des roches volcaniques, contrairement aux roches des continents, on devine aisément que les mers sont des structures d'origine volcanique, formées supposément par l'épanchement de grandes quantités de lave.

Les continents lunaires sont remplis de cratères, preuve qu'il s'agit de surfaces anciennes, pas beaucoup remaniées par le volcanisme ou la tectonique. À l'inverse, les mers lunaires sont plates et sans cratères, ce qui prouve qu'elles ont subi un volcanisme massif qui a effacé les cratères.  On peut déterminer l'âge de formation de la croûte en comptant les cratères : plus une portion de croûte est âgée, plus elle a reçu d'impacts depuis sa formation. Le comptage des cratères indique que les mers lunaires se sont formées il y a environ 3 à 4 milliards d'années. Quelques mers semblent cependant avoir un âge plus faible, d’environ 1,2 milliard d'années. De nos jours, plus de volcanisme : le manteau de la Lune s'est presque totalement solidifié et le volcanisme est épisodique.

===La face visible et la face cachée===

Les mers lunaires sont inexistantes sur la face cachée, cette dernière étant recouverte de continents. Les continents lunaires recouvrent près de 85% de la surface lunaire, dont la totalité de la face cachée et 65% de la face visible. Les 35% de la face visible sont recouverts par 22 mers lunaires différentes. Et ce n'est pas la seule différence visible entre les deux faces. Par exemple, l’élévation semble plus importante sur la face cachée que sur la face visible depuis la Terre. Si on mesure l’attitude moyenne sur les deux faces, on trouve une différence de 19,8 kilomètres de hauteur, ce qui est loin d'être négligeable. Une autre différence est l'épaisseur de la croûte : la croûte est plus épaisse sur la face cachée que sur la face visible. Là où la croûte fait 60 kilomètres d'épaisseur sur la face visible, elle en fait près de 110 sur la face cachée. Personne ne sait expliquer l'origine des différences entre faces visible et cachée, à l'heure actuelle. Certains chercheurs supposent un lien avec des effets de marée, d'autres supposent un impact d’astéroïde, d'autres une variation de composition chimique du manteau entre les deux faces, etc.

[[File:Moon crustal thickness map NASA-JPL.jpg|vignette|Carte montrant l'épaisseur de la croûte lunaire. On voit qu'elle est plus mince sous les cratères d'impacts, mais aussi que la croûte est plus mince sur la face éclairée. Les terrains ''procellarum'' et le pole sud montrent des zones de faible épaisseur crustale, dont l'origine est encore débattue.]]

Il est possible qu'il y ait un lien entre la localisation des mers et l'épaisseur de la croûte. Les planétologues qui souscrivent à cette hypothèse partent du principe que les mers lunaires sont des conséquences de cratères d'impact très puissants. Elles se sont formées quand ces impacts ont fracturé la croûte, formant des fissures par lesquelles la lave des mers est sortie. Sur la face visible, des impacts de météorite auraient creusé des bassins/cratères assez profonds, suffisamment pour casser la croûte et permettre au magma de s'épancher en surface. Sur la face cachée, la croûte épaisse aurait servi de bouclier contre les impacts, empêchant aux mers de se former. Cette hypothèse est bien étayée, mais on peut signaler qu'il n'y a pas de mers lunaires au pôle sud où la croûte est la plus mince. Pour le moment, on dispose plus d'hypothèses que de réponses et les planétologues ont encore du pain sur la planche.

===Les mers lunaires===

Tout indique que les mers sont de gigantesques épanchements de lave solidifiée, plus précisément de basalte. Leur formation est encore mal connue, mais les chercheurs ont des explications assez étayées. Les uns proposent que certaines mers se sont formés suite à des cratères d'impacts, qui auraient fissuré la croûte et inondé le cratère de lave. D'autres proposent des éruptions exceptionnelles par leur ampleur, qui auraient inondé des bassins de grande ampleur. Les deux hypothèses sont complémentaires, certaines mers collant bien à la première explication, d'autres collant mieux à la seconde.

Certaines éruptions ont rempli des '''cratères d'impact''', ce qui fait penser que les éruptions seraient consécutives à des impacts d’astéroïdes : ceux-ci fractureraient la croûte lunaire et permettraient au magma de remonter en surface. La ''Mare Imbirum'' et la mer de la sérénité sont deux exemples de mers lunaires formées par un cratère d'impact. Preuve en est, on trouve des éjectas autour de ces deux mares, des roches projetées hors du cratère lors de l'impact. De plus, les mesures gravimétriques mentionnées plus haut sont compatibles avec une telle origine. Enfin, elles ont une forme de cuvette aux bords circulaires, qui est compatible avec un impact.

Néanmoins, certaines mers lunaires ne semblent pas liées à des cratères d'impact. Des chercheurs supposent que la lave est sortie par de gigantesques fissures, à travers la croûte lunaire. Des éruptions de ce genre ont lieu sur Terre, et sont appelées des '''éruptions fissurales'''. La mer ''Oceanus Procellarum'' en est un bon exemple. Les premières hypothèses sur sa formation postulaient un gigantesque impact d’astéroïde, mais la forme de cette mare, qui n'est vraiment pas elliptique ou circulaire, ne semblait pas être compatible avec cette hypothèse. Des mesures gravimétriques récentes ont montré que cette mare est entourée d'un réseau de fractures, semblable à un gigantesque rift. Cela renforce ainsi une hypothèse concurrente : cette mare se serait formée par un volcanisme des plus classiques, lié à des phénomènes localisés dans le manteau de la Lune.

[[File:14-236-LunarGrailMission-OceanusProcellarum-Rifts-Overall-20141001.jpg|centre|vignette|upright=2.5|Oceanus procellarum, vu à des profondeurs différentes - Mesures gravimétriques provenant de la mission Lunar Grail.]]

===Les ''Winkle ridges''===

À la surface des mers, on trouve des fissures formées lors du refroidissement du basalte, par contraction thermique. Ces fissures sont appelées des '''Wrinkle ridge'''. Par exemple, on peut citer la ''Dorsa Smirnov''.

[[File:Dorsa Smirnov - LROC - WAC.JPG|centre|vignette|upright=2.0|Dorsa Smirnov - LROC - WAC]]

===Les dômes et cônes volcaniques===

[[File:Hortensius Domes (LRO).png|vignette|Dôme volcanique lunaire, ici le dôme ''Hortensius Domes'', photographié par la sonde LRO.]]

On trouve aussi des dômes de lave, similaires aux dômes des volcans péléens. Ces dômes ont une taille de plusieurs kilomètres de diamètre, guère plus. Par contre, ces dômes sont composés de basaltes, contrairement à ce qu'on trouve sur Terre où les dômes sont composés de laves beaucoup plus visqueuses et riches en silice. Ce qui fait que les dômes lunaires ont des pentes douces, entre 1 et 8 degrés de pente, contrairement aux dômes terrestres aux pentes plus abruptes. De plus, les dômes lunaires possèdent un cratère d'environ 1 kilomètre à leur sommet, alors que les dômes terrestres n'en ont pas. Le plus connu est le Mons Rümker, un ensemble de 30 dômes distincts qui se sont accumulés sur une même zone, mais on trouve aussi des dômes dans la région des Gruitheisen Domes, et dans la zone des Marius Hills. De tels regroupements de dômes sont monnaie courante et presque tous les dômes lunaires sont dans ce cas. On les trouve sur les bords des mers lunaires, là où la lave est peu épaisse, ce qui peut signifier que la chambre magmatique de ces volcans est proche de la surface.

À côté des mers, on trouve de petits édifices volcaniques, similaires aux cônes volcaniques communs sur Terre.

===Les dépôts mantelliques sombres===

Certaines portions de la croûte lunaire sont recouvertes par des dépôts de cendres, qui recouvrent les portions claires de la croûte : ce sont les '''dépôts mantelliques sombres'''. Ces dépôts ne sont pas visibles depuis la Terre, mais apparaissent au télescope : ils ont une couleur qui peut être jaune, rouge, ou verte. Ces dépôts sont proches de cônes volcaniques éteints. Le plus large d'entre eux se situe dans la Sinus Aestum, à l'est du cratère Copernicus.

===Les rainures sinueuses===

On trouve aussi des espèces de canaux, appelés '''rainures sinueuses''', ou encore '''''rilles'''''. Elles forment des canaux qui serpentent sur la surface de la lune. La plupart sont des coulées de lave solidifiées. D'autres sont des vestiges de tunnels de lave solidifiés : ce sont les rilles sinueuses. Elles commencent généralement à un cratère d'impact ou un petit édifice volcanique qui fait saillie à la surface de la croûte. Le meilleur exemple est la Vallis Schröteri, montrée sur cette image provenant d'Apollo 15.

[[File:Vallis Schroteri 4158 h1.jpg|centre|vignette|upright=2.0|Vallis Schroteri 4158 h1]]

===Les ''Irregular Mare Patches''===

Les astronomes ont pu observer, au cours de l'année 2014, de petits épanchements de lave solidifiée, qui ne sont pas visibles depuis la Terre. Ces épanchements sont très récents d'un point de vue géologique : ils datent d'environ 100 à 50 millions d'années, soit à peu près la fin des dinosaures sur Terre. Ces épanchements ne font pas plus de 500 mètres de long, et sont peu nombreux : on n'en dénombre que 75 sur toute la surface de la Lune. On nomme ces structures des ''Irregular Mare Patches'', ce nom leur provenant de leur forme, très irrégulière, avec des zones sombres lisses entremêlées de zones claires et craquelées. Peu de recherches ont été effectuées à l'heure où j'écris cet article (1er Janvier 2015) : seule une étude de la Nasa, datée d'Octobre 2014 est disponible à ma connaissance. L'article en question, publié par la NASA, se nomme &quot;''Evidence for basaltic volcanism on the Moon within the past 100 million years''&quot;.

===Les failles lunaires===

[[File:Rupes Recta Birt crater AS16-M-2486 ASU.jpg|vignette|''Rupes Recta'', une faille lunaire formée suite au poids des roches volcaniques des mers.]]

La surface lunaire est fracturée, avec de nombreuses failles de grande ampleur. Ces failles ne sont pas le résultat d'une tectonique des plaques, absente sur la Lune, mais sont le résultat d'impacts d’astéroïdes et de processus gravitaires.

Le premier type de faille se trouve sur les mers lunaires ou sur les terrains avoisinants. Les roches des mers lunaires forment des épanchements assez épais, de plusieurs centaines de mètres minimum. Tout cela pèse sur la croûte et implique un ajustement isostatique assez marqué, parfois une fragilisation des roches sous-jacentes. L'effet est plus marqué au centre des mers lunaires que sur leurs bords, pour une raison simple : les roches des mers lunaires sont plus épaisses au centre que sur leurs bords. L'épanchement de lave ne dépasse guère la centaine de mètres aux bords des mers lunaires, mais peu aller jusqu'à plusieurs kilomètres en leur centre. Le poids y est alors tel que la croûte sous-jacente s'est fracturée, donnant naissance à des failles, des ''grabens'' d'effondrement, des dorsales et d’autres structures tectoniques similaires.

Un second type de faille lunaire, les '''rainures rectilignes''', regroupe les failles formées suite à une extension de la croûte. Elles ressemblent fortement aux grabens et aux rifts observés sur Terre, avec un fond plat entouré par deux failles opposées. Mais elles ont une taille assez petite, ce qui signifie que les rainures rectilignes se sont formés non pas à cause d’une tectonique des plaques, mais sous l'influence de phénomènes locaux. L'extension est liée au volcanisme, preuve en est qu'une large minorité de rainures rectilignes est proche d'édifices volcaniques, que ce soit des dômes, des cônes ou des mers lunaires. Elles se formeraient suite à des infiltrations de magma dans les roches lunaires, similaires aux dykes terrestres, qui écarterait les roches lunaires en remontant vers la surface.

===Les cratères d'impact et les réplétions===

Les cratères d'impact sont monnaie courante sur les continents, plus rares sur les mers lunaires. On en trouve de toutes tailles, les plus petits faisant quelques mètres ou moins, alors que les plus gros cratères font plusieurs dizaines de kilomètres de diamètre. Pour donner quelques chiffres, il existe plus de 300 000 cratères de diamètre supérieure au kilomètre, sur la face visible. Comme on l'a dit dans le chapitre sur les chutes d'astéroïdes, la forme du cratère dépend de sa taille : simple (bol renversé) pour les petits cratères, fond plat avec pic central pour les plus gros. Avec cependant une petite particularité : les cratères les plus gros ont un fond noyé par la lave. Les impacts qui ont donné les plus gros cratères étaient assez puissants pour briser la croûte lunaire, ce qui a permis de remplir leur fond d'un lac de lave. Lac de lave qui s'est ensuite solidifié, ce qui explique pourquoi les grands cratères lunaires ont un fond plat (ou presque). Dans les cratères qui ont donné naissance aux mers lunaires, la lave a débordé du cratère, l'ensevelissant complètement. D'autres cratères ont aussi été ensevelis sous les mers lunaires alentours. On peut repérer ces cratères enfouis sur les enregistrements gravimétriques. Dans d'autres cas, les bords du cratère se sont brisés sous la pression de la lave, donnant naissance à un petit épanchement de lave, qui s'est répandu sur les pentes du cratère.

[[File:MareSmithiiTG.jpg|vignette|Illustration de la réplétion de la ''Mare Smithii''. La topographie est illustrée en haut, alors que les mesures gravimétriques sont illustrées en bas de l'image. On voit que le cratère d'impact est associé à une bosse gravimétrique.]]

La croûte lunaire est moins épaisse sous les cratères d'impact et qu'elle y est parfois absente ! Les données satellites montrent la présence d'anomalies gravitaires au-dessus de certains cratères, qui s'expliquent par des accumulations de matériaux denses auxquelles on a donné le nom de '''réplétions''' (le terme anglais est ''mascons''). Elles sont composées d'un centre où l'anomalie gravitaire est maximale, entouré de cercles concentriques où la gravité alterne entre valeurs inférieures et supérieures à la normale. Leur forme, similaire à celle d'une onde, laisse penser qu'elles se forment suite à l'impact qui donne naissance au cratère, sous l'effet de l’onde de choc. Leur origine est vraisemblablement liée à des remontées mantelliques, induites par la déformation de la croûte par l'onde de choc et par la formation du cratère d'impact. Plusieurs processus permettent d'expliquer la forme exacte des réplétions.

* La remontée mantellique centrale est liée à la disparition de la matière sous le cratère d'impact proprement dit. Le creux laissé par le cratère d'impact est en quelque sorte rempli par la remontée du manteau sous-jacent. La croûte étant amincie, elle pèse moins qu'avant sur le manteau, ce qui le fait remonter vers la surface pour rétablir l'équilibre isostatique. Cependant, la croûte est rigidifiée par l’impact et par le remplissage du cratère. Elle forme une sorte de couvercle rigide qui empêche le manteau de remonter suffisamment pour rétablir l'équilibre isostatique. Il reste alors une anomalie gravitaire positive, signe que la remontée mantellique ne compense pas la perte crustale.
* Le cercle concentrique autour de la remontée centrale s'explique par le déplacement de matière lunaire par les éjectas. L’impact fait fondre la matière lunaire et la disperse autour du cratère d'impact. La fusion des roches lunaires lors de l'impact, puis leur re-solidification, en augmente la densité. L'accumulation de cette matière densifiée autour du cratère amplifie la gravité tout autour, creusant le cercle de gravité supérieure qui entoure le cratère.
* Les cercles concentriques plus éloignés s'expliquent par la propagation de l'onde de choc formée lors de l'impact. Suite à l'impact, l'onde de choc se propage dans la croûte et la déforme. L'interface entre la croûte et le manteau est aussi déformée par l'onde de choc, ce qui fait remonter le manteau dans les creux de l'onde, et le fait sous dans les bosses. Au bout d'un moment, l'onde de choc se dissipe et les mouvements du manteau vont stopper. Mais le manteau se déformant différemment de la croûte, les vagues formées par l'onde de choc sur l'interface croûte-manteau vont &quot;se figer&quot; et donner les mascons. 

[[File:Orientale basin GRAIL gravity.jpg|centre|vignette|Anomalies gravitaires sous le cratère d'impact &quot;bassin orientalis&quot;. On voit bien les cercles concentriques de la zone de réplétion.]]

==Les roches lunaires : chimie et pétrographie==

À la surface, les roches lunaires ont une composition chimique similaire à celle des roches terrestres, avec quelques variations idiosyncratiques assez significatives. La Lune a une densité très faible, d'environ 3,4, qui fait d'elle le satellite rocheux le moins dense. La faible densité de la Lune fait qu'elle a une très faible gravité, insuffisante pour conserver une atmosphère. L'absence de réactions géochimiques avec une atmosphère rend la chimie de la surface assez pauvre, nettement moins diversifiée que celle de la Terre. La chimie lunaire dépend principalement essentiellement du magmatisme et du volcanisme. La chimie de la croûte lunaire n'a pas beaucoup évoluée depuis la formation de la Lune, si ce n'est sur sa surface, en raison du volcanisme. La surface a aussi évoluée suite à divers processus d'érosion, qui sont loin d'être négligeables sur la Lune, contrairement à ce qu'on pourrait croire. Dans ce qui suit, nous allons voir la chimie de la croûte (dépendante du magmatisme) avant celle du sol lunaire, influencée par l'érosion spatiale.

===La croûte lunaire===

À eux seuls, quatre types de minéraux constituent 98% de la croûte lunaire : l'olivine, les feldspaths plagioclases, les pyroxènes, et les oxydes. L'absence d'eau à la surface se retrouve dans les météorites lunaires et les échantillons d'Apollo : les roches lunaires n'ont pas de minéraux hydratés, comme on en trouve sur Terre. Les analyses géochimiques des échantillons ramenés par les missions Apollo et des météorites lunaires, ainsi que les observations spectroscopiques de la surface lunaire, montrent une grande différence entre la composition des mers lunaires et celle des continents. Les continents lunaires sont composés d'Anorthosites (une roche riche en Aluminium et en Calcium, mais pauvre en Fer, en Magnésium et en Titane), alors que les mers lunaires sont composées de basaltes. On trouve aussi des roches nommées Dunite, la Trocolite, Gabbro, Anorthosite alcalines, Norites, Gabbronorites, mais dans des proportions bien plus faibles que les basaltes et Anorthosites.

[[File:Moon vs earth composition.svg|centre|vignette|upright=1.5|Moon vs earth composition]]

Les Anorthosites des continents se sont formées vers de 4,4 milliards d'années et sont donc la roche lunaire originelle, mais on ne peut pas en être vraiment sûr. Il faut dire que les nombreux impacts d'astéroïdes ont remodelé les roches lunaires, au point que les échantillons de roches primaires sont très rares, exceptionnels. Les roches lunaires sont presque toutes métamorphisées, refondues, fragmentées, choquées, etc. Ce sont des brèches, à savoir des roches formés de nombreux fragments rocheux agglomérés entre eux. Au niveau isotopique, les roches des continents lunaires sont enrichies en Europium et en Strontium, deux éléments chimiques assez rares, qui ont une affinité particulière pour les Feldspaths plagioclase.

Les mers lunaires sont composées de basaltes, semblables aux basaltes terrestres, mais qui ont une composition chimique légèrement différente : ils sont plus riches en FeO et TiO2, mais plus pauvres en Al2O3. Ils sont légèrement plus riches en olivines et pyroxènes que les terrains environnants, mais pauvres en Feldspath plagioclase. Au niveau isotopique, les basaltes des mers lunaires sont appauvris en Europium et en Strontium, contrairement aux continents lunaires. Ces anomalies semblent complémentaires, ce qui tend à montrer que les basaltes des mers et les roches continentales se seraient formées à partir d'un même magma, qui se serait différencié, séparé en deux phases distinctes. Nous en reparlerons quand nous parlerons de l'évolution du manteau lunaire.

Suivant la mer en question, le basalte n'a pas la même composition : les observations dans l'ultraviolet et l'infrarouge ont identifié environ 13 types de basaltes différents sur les mers lunaires. Certains de ces basaltes sont inconnus sur Terre. Ces basaltes sont riches en potassium, phosphore, et en terres rares : on les appelle des '''basaltes KREEP'''. KREEP est l'abréviation de K - REE - P, qui veut dire : Potassium, ''Rare Earth Element'', Phosphore. Ces basaltes KREEP sont localisés dans les mers ''Oceanus Procellarum'' et la ''Mare Imbrium'', et ne se trouvent nulle part ailleurs. Cela se voit sur les cartes de la concentration en Thorium de la croûte lunaire.

[[File:Lunar Thorium concentrations.jpg|centre|vignette|upright=2.0|Lunar Thorium concentrations]]

Beaucoup de basaltes lunaires possèdent des vides appelés ''vésicules'', formées par des bulles de gaz &quot;fossilisée&quot; lors de la solidification de la roche. Les gaz en question ne devait pas différer fortement des gaz volcaniques terrestres, à quelques différences mineures. Ils devaient être composés en majorité de dioxyde de carbone, avec de faibles quantités de Soufre. Par contre, l'absence d'eau dans les roches unaires fait que ces gaz ne devaient pas contenir beaucoup de vapeur d'eau.

[[File:Lunar Sample 15016 Air and Space Museum.jpg|centre|vignette|upright=2.0|Échantillon de basalte lunaire ramené par les missions Apollo.]]

===Le régolite lunaire===

[[File:Composition of lunar soil.svg|vignette|upright=1.0|Composition of lunar soil]]

La surface de la Lune a été soumise à une érosion particulière, l''''érosion spatiale''', qui a formé un &quot;sol&quot; lunaire : le régolite. Celle-ci a donné naissance à un régolite constitué de plusieurs couches (de la moins profonde à la plus profonde) :

* un méga-régolite composé de poussières et de particules très fines ;
* une couche d'éjectas, des débris éjectés et déposés lors de gros impacts de météorites ;
* une zone composée de blocs, avec des particules intercalées ;
* une zone de fractures, formée par les impacts ;
* la roche-mère, préservée des impacts.

Sa composition chimique est différente de celle des roches terrestres, non pas que les éléments chimiques soient différent, juste les proportions qui ne sont pas les mêmes. Le régolithe est très riche en Oxygène, comme les roches terrestres, mais est aussi riche Hydrogène, Hélium, Carbone, Azote, etc. Mais contrairement aux précédents, ces éléments ont été apportés sur la Lune de l'extérieur : ils viennent du vent solaire et sont de purs apports liés à l'érosion spatiale. À noter que le pôle sud de la Lune est plus riche en Hydrogène que les mers et continents, ce qui est lié à la présence de glace à cet endroit. Mais rien de certain pour le moment. Outre ces éléments chimiques apportés de l'extérieur, le régolithe en métaux : Soufre, Fer, Magnésium, Manganèse, Nickel. Ces derniers sont présents dans les roches sous une forme oxydée, à savoir associés à de l'Oxygène. C'est surtout au niveau des mers que le régolithe est riche en métaux et en terres rares, preuve que des métaux étaient là dès la création de la Lune et sont arrivés en surface par le biais du volcanisme.

==La sismologie lunaire et sa structure interne==

[[File:Affiche de la lune.svg|vignette|upright=1.5|Structure interne de la lune.]]

Les missions Apollo 12, 14, 15 et 16 ont laissé des sismomètres sur la Lune, pour enregistrer les ondes sismiques des tremblements de Lune. Ces sismomètres ont fonctionné jusqu'en 1977, et ont enregistré 1800 impacts de météorites, 28 séismes de surface et plusieurs centaines de séismes profonds. L'analyse des données sismiques a été très utile aux planétologues et a principalement permis de connaître l'intérieur de la Lune. Ils ont pour cela utilisé les mêmes techniques que les géologues, qui utilisent les séismes pour sonder l'intérieur de la Terre. Les données sismiques nous disent que la Lune est structurée en plusieurs couches, comme toutes les planètes telluriques. L'ensemble a une structure interne assez similaire à celle de la Terre : une croûte et un manteau de silicates, et probablement un noyau ferreux.

Les séismes lunaires se classent, selon leur profondeur, en trois grands types :
* Les '''séismes de surface''' ont leur foyer dans la croûte (20 à 30 kilomètres de profondeur). Ils sont causés soit par des impacts de météorites, soit par le réchauffement de la croûte lorsque le jour revient (les journées durent 2 semaines sur la Lune).
* Les '''séismes de profondeur intermédiaire''' proviendraient du refroidissement de la Lune. En refroidissant, les roches se contracteraient au point de casser, causant des séismes de forte ampleur. De tels séismes sont observés, avec une magnitude 4 à 5, même s'ils sont très rares.
* Les '''séismes profonds''' (700 kilomètres de profondeur) sont plus rares et leurs mécanismes de déclenchement sont mal connus. On pense qu'ils sont dus aux marées, vu que ces séismes se déclenchent avec une régularité assez nette : tous les 27 jours pour un même hypocentre, sans compter les périodes de 206 et 6 ans liées aux marées (via la forme de l'orbite de la Lune). Chose étrange, ces séismes profonds proviennent d'un ensemble de 300 foyers tous situés dans la face visible : soit la face cachée est sismiquement inactive, soit quelque chose empêche les ondes de passer de l'autre côté de la planète (un noyau fluide est une bonne explication).

[[File:MoonStructure.jpg|centre|vignette|upright=2.0|Localisation des séismes lunaires en fonction de leur profondeur, avec la structure interne de la Lune. On voit que les séismes profonds sont tous localisés du côté de la face visible, aucune source n'étant enregistrée du côté de la face cachée.]]

===La croûte lunaire===

Dans l'ensemble, la structure de la croûte est la suivante :

* Les premières centaines de mètres, composées de gravats, laissent bien passer les ondes sismiques.
* À moins d'un kilomètre de profondeur, les ondes sismiques ralentissent lors du passage du régolithe à la croûte.
* Entre 1 et 20 kilomètres de profondeur, la vitesse des ondes sismiques indique qu'elles traversent un matériau basaltique. La vitesse augmente doucement avec la profondeur, ce qui indique que le basalte voit sa densité augmenter progressivement avec la profondeur.
* De 20 à 60 kilomètres, les ondes sismiques traversent une couche riche en Anorthosite, la roche qui compose les continents lunaires.
* Plus profondément, la croûte laisse place au manteau et la zone de transition est assez brutale.

===Le manteau lunaire===

L'étude du manteau provient essentiellement de l'analyse des séismes lunaires et des roches profondes exhumées. Il est presque certain que le manteau est riche en Fer et en Magnésium. Au niveau des minéraux, le manteau lunaire doit essentiellement être constitué de Pyroxène et d'Olivine. L'ensemble a une composition chimique et minéralogique assez similaire à celle de la Terre et des autres planètes telluriques.

Il est supposé que le manteau est presque intégralement solide et cassant, avec cependant une incertitude quant au manteau profond, qui pourrait être liquide. L'étude des ondes sismiques ne donne pas de résultats clairs et nets, à l'heure où j'écris ces lignes. Les analyses des données Apollo semblent indiquer la présence d'une discontinuité sismique à 500 kilomètres de profondeur. Une autre discontinuité existerait vers 580 kilomètres de profondeur : en dessous, le manteau serait partiellement fondu, donnant un océan de magma. Mais les études plus récentes ne sont pas aussi affirmatives : certaines valident les premières analyses, d'autres donnent des résultats contradictoires et arrivent à expliquer les données sismiques sans avoir besoin du moindre océan de magma. Certaines ne retrouvent même pas la discontinuité des 500 kilomètres. Pas de consensus, donc.

===Le noyau lunaire===

L'existence du noyau central est encore hypothétique, divers indices n'étant pas vraiment compatible avec son existence, tandis que d'autres s'expliquent mal sans lui. D'un côté les données sismiques et l'existence du champ magnétique vont dans le sens d'un noyau ferreux, de l'autre la densité de la Lune pose problème. La densité de la Lune est presque identique à la densité de ses roches de surface : 3,34 pour la Lune, contre 3,3 pour les roches de surface. Cela indique que la Lune n'a pas de noyau, ou alors que celui-ci est très petit. En tout cas, on sait que si le noyau lunaire existe, il est très petit et ne dépasse pas les 700 kilomètres de diamètre.

Pourtant, les magnétomètres des missions lunaires montrent que la Lune a un faible champ magnétique qui semble provenir de l'aimantation de la croûte. Une hypothèse est que ce champ magnétique est le vestige d'un ancien champ magnétique, fossilisé dans les roches lunaires lors de la solidification de la croûte. Si c'est vrai, cela signifie que la Lune dispose bien d'un noyau, mais la petite taille du noyau semble incompatible avec la valeur mesurée du champ magnétique. Une hypothèse alternative dit que le champ rémanent s'est formé par &quot;mémorisation&quot; de champs magnétiques transitoires, qui surviennent lors d'impacts de météorites.

==L'histoire géologique de la Lune==

Comme dit plus haut, les roches lunaires et terrestres sont similaires sur les plans chimiques et isotopiques. Cette ressemblance dans les compositions chimiques et isotopiques laisse à penser que la Lune se serait formée suite à un gigantesque impact de météorite sur Terre. L'impact aurait soufflé une portion importante du manteau terrestre dans l’espace les débris s'étant ensuite agglomérés pour former la Lune. Cela expliquerait pourquoi la Lune est pauvre en Fer et en métaux : l'impact n'a pas touché le noyau et n'a donc pas propulsé de métaux dans l’espace. L’astéroïde qui s'est écrasé sur la proto-Terre est appelé Theia, aurait une masse proche de 20 % de la masse terrestre actuelle, et son orbite aurait été proche de celle de la Terre. La théorie la plus en vogue suppose que Theia se serait formé sur un point de Lagrange, avant de se rapprocher progressivement de la Terre par vagues successives, jusqu'à s'écraser sur Terre 20 millions d’années plus tard.

[[File:BigSplashFrench.svg|vignette|upright=1.0|BigSplashFrench]]

[[File:Fr-Bigsplashsimple.png|centre|vignette|upright=2.0|Formation de la Lune par impact.]]

===La séparation de la croûte et du manteau===

Durant sa jeunesse, la Lune a été chauffée par les impacts de météorites et par la désintégration d’éléments radioactifs. Elle a ainsi été complètement fondue, formant une grosse boule de magma. Mais cet océan de magma a fini par se solidifier progressivement, donnant naissance à la croûte et au manteau lunaire. Les premiers minéraux solides qui se sont formés ont été l'olivine, les pyroxènes, les feldspaths plagioclase et de l'orthopyroxène, suivis par quelques minéraux annexes. Il se trouve que ces minéraux sont plus denses que le magma qui leur a donné naissance, à une exception : les feldspaths plagioclase. Ils ont donc sédimenté vers la base du manteau, laissant les feldspaths plagioclase flotter sur l'océan de magma, et donnant naissance à la croûte. Le résultat est un manteau riche en pyroxènes (ortho et clino-pyroxènes) et en olivine, surmonté par une croûte d'anorthosite.

[[File:FormationLune.svg|centre|vignette|upright=2.0|Séparation du manteau et de la croûte lunaire.]]

La croûte lunaire s'est formée ainsi lors de la solidification de la Lune, quand l'océan magmatique lunaire s'est différencié. Sachant que le même mécanisme a eu lieu sur toutes les planètes telluriques, Terre incluse, on peut se demander pourquoi la Lune est la seule à avoir une croûte d'anorthosite. La Terre, Mars, Venus, et de nombreux autres corps telluriques, ont une croûte primordiale basaltique, pauvre en Feldspaths plagioclase. Une des raisons tient dans la faible gravité de la Lune, qui est 80 fois plus faible que celle de la Terre. De ce fait la pression n'augmente pas trop avec la profondeur, contrairement à ce qu'on observe sur les autres corps telluriques plus massifs. Cela permet à certains minéraux de se former à des profondeurs importantes, alors que ce n'est pas le cas sur Terre : du feldspaths plagioclase a pu se former sur la Lune car la pression dans le manteau était assez faible, là où la pression du manteau terrestre l'interdit. Ainsi, le feldspath peut se former sur Terre jusqu'à 30 kilomètres de profondeur, alors qu'on en trouve jusqu’à 180 kilomètre de profondeur dans le manteau lunaire. Autant dire que la Lune a eu suffisamment de place pour former assez de plagioclase pour sa croûte, là où les autres corps telluriques n'ont pas eu cette chance. On estime que si la Terre avait pu former une croûte d'anorthosite primaire, celle-ci aurait été 6 fois épaisse que celle de la Lune.

De plus, les conditions de température et de pression différentes ont fait que les minéraux ont cristallisés dans un ordre différent : sur Terre, les clinopyroxènes ayant cristallisé en premier, suivis par l'olivine, puis enfin par les plagioclases. Sur Terre, les pyroxènes et l'olivine ont cristallisé en premier, accompagnés par du grenat. Ces minéraux, plus denses, ont coulés au fond de l'océan de magma pour s'accumuler au fond du manteau liquide. Le manteau supérieur s'est alors enrichi d'un magma pauvre en grenat, olivines et pyroxènes, alors que le manteau inférieur s'en est enrichi. L'anorthosite ne s'est pas formée en grandes quantités et n'a pas pu s'accumuler au point de former une croûte solide. À la place, la surface de l'océan de magma s'est solidifiée avant même la ségrégation des plagioclase vers la surface. Ce scénario est cependant approximatif et sa validité dépend fortement de la vitesse de refroidissement de la croûte et de la présence d'eau à la surface de la Terre. L'eau a en effet pu permettre une altération précoce des roches crustales, les rendant moins denses que l'océan de magma, avant ou pendant la ségrégation. Toujours est-il que la composition chimique de la première croûte est assez mal connue à l'heure actuelle, et que de nombreuses incertitudes ruinent notre connaissance de la formation de la croûte terrestre. Mais revenons à la croûte lunaire.

La croûte lunaire a évolué après sa formation, en raison de la formation des mers lunaires et d'intrusion magmatiques. Passons sur le second point, qui veut que du magma mantellique se soit infiltré dans la croûte et ait donné naissance à grand nombre de plutons et d'intrusions granitiques (oui, on trouve des granites sur la Lune). Ce mécanisme n'est pas bien différent de ce qu'on observe sur Terre, à la différence près que la gravité plus faible de la Lune doit faciliter ce mécanisme, et que sa faible chaleur interne ait limité la durée de ce mécanisme aux premiers milliards d'années de son existence. La formation des mers lunaires a eu une importance bien plus grande sur la croûte lunaire.

Les basaltes des mers ont une origine mantellique, et sont donc tirés de la fusion d'un résidu d'olivine et de pyroxènes. Les basaltes KREEP se sont formés vers la fin de la solidification de la Lune, quand l'océan de magma était presque totalement solidifié. Ils se sont formés entre la croûte de Feldspath et le manteau riche en Pyroxènes, par un mélange entre les magmas de la croûte et du manteau profond. Les KREEP sont ensuite remontés en surface suite à divers impacts de météorite, par excavation de la croûte qui a mis à nu les roches mantelliques de type KREEP. C'est pour cela qu'on les trouve surtout dans l'Oceanus Tempestus, le cratère d'Aitken du pôle sud et quelques autres cratères d'impact.

On peut noter que cela explique pourquoi les mers lunaires sont pauvres en Europium et Strontium, alors que les continents en sont enrichis. Europium et Strontium ont une affinité particulière pour les feldspaths plagioclase, qui sont naturellement enrichis en ces deux éléments chimiques. Lors de la séparation de la croûte du manteau, Europium et Strontium se sont retrouvés dans la croûte des continents, en même temps qu'ils quittaient le manteau pour la croûte. Le résultat est donc un manteau pauvre en Europium et Strontium et une croûte enrichie.

===L'évolution géologique après la formation de la croûte===

Une fois la croûte solidifiée, la chaleur a été la source du volcanisme lunaire. Cependant, la Lune était beaucoup plus petite que la Terre. En conséquence, elle contenait beaucoup moins d’éléments radioactifs : ce stock s'est rapidement épuisé, et la production de chaleur a rapidement diminuée. Le manteau de la Lune a donc refroidi assez rapidement. La tectonique des plaques n'a pas eu le temps de se mettre en place, et le manteau a rapidement solidifié dans sa partie supérieure. Depuis, la Lune est un astre géologiquement mort. Cela explique pourquoi le volcanisme de la Lune est assez ancien, alors que le volcanisme terrestre est toujours très actif.

{{NavChapitre | book=Planétologie
           | prev=Les satellites et anneaux planétaires
           | prevText=Les satellites et anneaux planétaires
           | next=Les satellites de Jupiter
           | nextText=Les satellites de Jupiter
}}

{{AutoCat}}</text>
      <sha1>hxq8xesrqrm5f9rt0wacazt3ifyt2u7</sha1>
    </revision>
  </page>
  <page>
    <title>Planétologie/Les météorites</title>
    <ns>0</ns>
    <id>69610</id>
    <revision>
      <id>684251</id>
      <parentid>679228</parentid>
      <timestamp>2022-08-27T14:47:52Z</timestamp>
      <contributor>
        <username>Romanc19s</username>
        <id>3047</id>
      </contributor>
      <comment>Orthographe &quot;ont subIII&quot;/* Les météorites différenciées */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="38939" xml:space="preserve">Les astéroïdes se sont formés lors de la formation du système solaire et sont des vestiges du disque protoplanétaire, au même titre que les comètes et autres petits corps du même genre. Ils peuvent nous donner des indices sur ce qu'il s'est passé dans le disque. Mais pour exploiter ces indices, encore faut-il avoir des astéroïdes sous la main. De fait, l'étude des astéroïdes par les méthodes astronomiques est souvent indirecte, les astronomes devant se limiter à analyser la lumière réfléchie par les astéroïdes. Mais les astronomes et géologues ont accès à des astéroïdes tombés sur Terre, les météorites.

[[File:Light microscope images of stony cosmic spherules.png|vignette|Sphérules cosmiques.]]

Les météorites sont en majorité des météorites minuscules, de masse inférieure au gramme, aussi appelées '''micrométéorites'''. Celles-ci sont de loin les plus nombreuses dans le milieu intersidéral, mais beaucoup survivent pas à la traversée de l'atmosphère. La plupart se vaporisent totalement avant d'atteindre le sol, ne formant pas de météorite. Il arrive cependant, dans certains cas particuliers, que la micrométéorite atteigne le sol. Dans la plupart des cas, il ne subsiste alors qu'une minuscule '''sphérule cosmique''' intégralement fondu. Mais il existe quelques rares cas de micrométéorites qui n'ont fondu que partiellement, voire très peu.

Les micrométéorites les plus fréquentes, mais leur étude est assez compliquée : la fusion de leur croûte efface leur structure interne et altère les minéraux de la météorite. Seuls les corps plus importants, qui survivent à la traversée de l'atmosphère, peuvent être étudiés sans biais. Il faut dire qu'ils donnent des météorites avec une croûte de fusion très mince par rapport à leur taille, l'intérieur  n'étant pas altéré par la fusion de la surface. Leur étude est alors facilitée et on peut étudier leur composition minéralogique et isotopique originelle. Mais ceux-ci sont beaucoup plus rares.

==Les classifications des météorites==

L'analyse des météorites se concentre surtout sur leur composition chimique et isotopique, les astronomes étudiant surtout les minéraux qu'elles contiennent. Il apparaît que la composition chimique des météorites est assez hétérogène, avec de nombreuses classes de météorites distinctes.

===La classification minéralogique et chimique===

Les analyses minéralogiques et chimiques permettent de classer les météorites en plusieurs catégories, qui portent les doux noms de '''météorites pierreuses''', '''météorites métalliques''' et '''météorites intermédiaires'''. On parle aussi de météorites silicatées, de sidérites et de lithosidérites. Les noms de ces catégories sont assez transparents : les premières sont purement rocheuses et entièrement composées de silicates alors que les secondes sont composées intégralement de Fer et de métaux. Les météorites intermédiaires ont une composition chimique intermédiaire entre les météorites pierreuses et métalliques. Les météorites pierreuses sont elles-mêmes subdivisées en deux classes : les chondrites et les achondrites. La différence tient dans la présence de petites sphères de silicates nommées chondres dans les chondrites, alors que les achondrites n'ont pas de tels chondres en leur sein.

Les quatre catégories précédentes (chondrites, achondrites, météorites ferreuses et intermédiaires) sont elles-mêmes subdivisées en plusieurs sous-classes distinctes par la présence ou l'absence de certains minéraux. La raison est que ces minéraux se forment dans des conditions de température et de pression bien précises. La présence de ces minéraux traduit les conditions de formation du matériel météoritique et son évolution. On peut ainsi savoir si la météorite s'est formée dans un environnement chaud ou froid, de pression élevée, etc. On peut aussi savoir comment sa matière a évolué, si elle a subi du métamorphisme ou des processus hydrothermaux ou tout autre évolution.

===La classification génétique===

[[File:Classification des météorites.png|vignette|upright=1.5|Classification des météorites]]

La classification précédente peut se reformuler en tenant compte de l'origine supposée des météorites, à savoir du type de corps dont elles proviennent. Les analyses montrent que certains astéroïdes ont eu le temps de se différencier, acquérant une structure interne avec un manteau et un noyau. Mais une majorité d’astéroïdes n'a cependant pas pu se différencier et a conservée la composition chimique du disque protoplanétaire. On classe ainsi les météorites en deux types : les '''météorites différenciées''' et les '''météorites non-différenciées'''.

Les météorites non-différenciées sont toutes des chondrites et leur classification est beaucoup plus complexe. On suppose que les différentes classes de chondrites indiquent le lieu de formation de la météorite dans le disque protoplanétaire. Celles formées près du Soleil seraient ainsi riches en éléments réfractaires, alors que celles formées loin du Soleil seraient riches en eau et en matière carbonée. Mais le grand nombre de catégories et sous-catégories de chondrites rend cette interprétation plus compliquée que prévu.

Les météorites différenciées sont elles-mêmes classées selon qu'elles proviennent du manteau ou du noyau de l’astéroïde, avec quelques catégories pour les météorites provenant des limites entre manteau et noyau. Celles-ci correspondent respectivement aux météorites pierreuses achondrites, sidérites, et lithosidérites. La plupart des achondrites proviennent de Mars, de la Lune et ou de l'astéroïde Vesta. Quelques autres sont cependant d'une origine inconnue, dans le sens où on ne sait pas quel leur astéroïde ou planète d'origine. De même, les sidérites et lithosidérites n'ont pas de corps parent certains.

{|class=&quot;wikitable&quot;
|-
!Météorites
!Pierreuses
!Ferreuses
!Pierreuses-ferreuses
|-
!Différenciées
|Achondrites
|Sidérites
|Lithosidérites
|-
!Non-différenciées
|Chondrites
| -
| -
|}

==Les météorites non-différenciées==

[[File:Allende meteorite.jpg|vignette|Météorite d'Allende (de type chondrite).]]

Les météorites non-différenciées, aussi appelées chondrites, sont les plus fréquentes : plus de 80% des météorites qui tombent sur Terre en sont. On suppose qu'elles se sont formées avec ce qui restait du disque protoplanétaire une fois les premiers planétésimaux formés. En conséquence, elles sont composées de silicates, avec parfois un peu de calcium ou de magnésium, de Fer et de Nickel.

===Les grains chondritiques et leur matrice===

Les chondrites contiennent de nombreux '''grains chondritiques''' approximativement sphériques, noyés dans une '''matrice chondritique''' solide, formée par des minéraux et du matériel amorphe (non-cristallisé). Les grains chondritiques sont assez différents les uns des autres, que ce soit en terme de chimie ou de minéralogie. On suppose que ces différences proviennent de leur origine : certains se sont formés juste après la formation du Soleil, d'autres quand le disque protoplanétaire a refroidi. Dans tous les cas, les différences entre grains permettent de les classer en trois grands types : les grains présolaires, les inclusions alumino-calciques et les chondres. Les chondres sont parfois appelés chondrules et ce sont ces grains qui ont donné leur nom aux chondrites.

====Les chondres====

[[File:Ordinary chondrite NWA 3189 Meteorite.jpg|vignette|Photographie zoomée de l'intérieur d'une chondrite, qui met bien en avant les chondres.]]

Les '''chondres''' sont des petites billes de silicates, qui contiennent des minéraux noyés dans un verre amorphe. Les minéraux des chondres sont majoritairement de l'olivine ou du pyroxène, avec parfois la présence de feldspaths et plus rarement de minéraux métalliques ou sulfurés comme l'anorthite. Elles ont une forme approximativement sphérique, parfois en forme de larme ou de goutte, comme si elles avaient été liquides. De plus, elles ont une texture magmatique assez prononcée. De ce fait, on peut déduire que ce sont à de petites larmes de magma, qui ont refroidi au point de se solidifier.

Leur refroidissement a visiblement été assez rapide, ce que traduit la présence de verre amorphe dans les chondres. Le magma n'a pas eu le temps nécessaire pour totalement cristalliser, la portion non-cristallisée ayant donné le verre, alors que la portion cristallisée a donné des minéraux silicatés. La proportion de verre varie grandement selon la chondrite, certaines ayant des chondres totalement vitreux, alors que d'autres ont une texture porphyrique, fortement dominée par des cristaux de petite taille orientés aléatoirement dans le verre. Dans le détail, les chondres sont classés selon la forme des minéraux et la proportion de verre, donnant deux grandes catégories : les chondres porphyriques et les chondres non-porphyriques, eux-mêmes subdivisés en plusieurs sous-types.

[[File:Chondrule Textures.jpg|vignette|Types de chondes, classés par leur texture. Photographie.]]
[[File:Kondrumok.gif|vignette|Types de chondes, classés par leur texture. Schéma.]]

{|class=&quot;wikitable&quot;
|-
!Type de chondre
!Sous-types de chondres
|-
!Chondres porphyriques
|
*A olivine porphyrique.
*A pyroxènes porphyriques.
*A olivine et pyroxènes porphyriques.
|-
!Chondres non-porphyriques
|
* Vitreux (complètement verreux)
* Cryptocristallins.
* A olivine barrée.
* A pyroxène fibroradié.
|}

====Les autres grains chondritiques====

Les chondrites contiennent aussi des '''inclusions réfractaires''', des grains riches en minéraux qui fondent à forte température (autrement dit, des minéraux réfractaires). Elles ont le plus souvent une couleur blanche, mais ce n'est pas systématique. Les inclusions réfractaires les plus communes sont des inclusions riches en olivine, qui portent le nom barbare d'agrégats amiboïdes à olivine. Ce nom à coucher dehors traduit leur richesse en olivine, mais aussi leur forme d'amibe (ou du moins, des minéraux d'une forme similaire) et le fait qu'elles sont formées de plusieurs minéraux regroupés ensemble, agrégés. En comparaison, les inclusions réfractaires plus anciennes sont de loin les inclusions aluminocalciques, des grains riches en Calcium et Aluminium, résultat des premières condensations des éléments réfractaires. Elles contiennent de nombreux minéraux riches en Al et Ca : diopside, spinelle, mélilite, de l'anorthite, du clinopyroxène, etc.

Très rarement, les chondrites contiennent des '''grains de métal purs'''. Ceux-ci sont composés de minéraux riches en Fer et en Nickel, qui portent les noms de Kamacite et de Taènite. Retenez bien ces deux termes, car nous les réutiliserons pour parler des météorites ferreuses. En effet, les métoérites ferreuses sont exclusivement composées de Kamacite et de Taénite, dans des proportions variables. Pas étonnant que les chondrites en contiennent un petit peu, sachant que les météorites différenciées sont nées de la différentiation de matériel chondritique.

La matrice est parfois polluée par des grains qui ne sont pas formés dans le disque, mais en dehors du système solaire. Ces '''grains présolaires''' proviennent d'étoiles alentours et ont été incorporé dans les chondrites lors de leur passage dans le système solaire. On les reconnaît par leur composition chimique et isotopique, fortement différente du reste de la matrice.

===L'âge des chondrites===

La datation par mesures isotopiques montre que les chondrites ont un âge de 4,5 milliards d'années, le même âge que le système solaire. Chrondrule, inclusions et grains de métal se sont vraisemblablement formés dans le disque d’accrétion, avant la formation des planètes. Les inclusions aluminocalciques se seraient formées en premier. Les datations leur donnent un âge de 4,567 milliards d'années, âge qui est considéré comme l'âge du système solaire. Les chondres se sont formés approximativement 2 millions d'années plus tard. L'âge des chondrites indique qu'elles se sont formées en même temps que le disque protoplanétaire, dans le disque et non dans un astre différencié.

===La classification chimique des chondrites===

Les chondrites sont classées en plusieurs grands types, en fonction de leur composition chimique et minéralogique :

* les '''chondrites carbonées''', riches en carbone ;
* les '''chondrites à enstatite''', riches en enstatite (un minéral silicaté) ;
* les '''chondrites ordinaires''', intermédiaires entre les deux précédentes ;
* les '''chondrites spéciales''', assez idiosyncratiques.

Cette classification aurait une interprétation physique : chaque catégorie de chondrite se serait formée à une certaine distance du Soleil (ou du moins, dans un intervalle précis de distance). Par exemple, les chondrites à enstatite se seraient formées dans la partie interne du disque, là où les planètes telluriques se sont mises en place. Leur composition chimique doit donc être proche de celle des planètes telluriques. Les chondrites carbonées se seraient formées à la lisière du système solaire, loin du soleil, ce que trahit leur composition chimique, similaire à celle des corps transneptuniens. Les autres chondrites se seraient formées au milieu du système solaire, pas trop loin de Jupiter et de la ceinture d’astéroïde. Les différences de composition chimique entre chondrites proviendraient de la répartition entre matériaux réfractaires et volatils dans le disque protoplanétaire. Les éléments légers, soufflés vers l'extérieur du disque, se retrouvent naturellement dans les chondrites formées loin du Soleil, à savoir les chondrites carbonées. Par contre, les éléments réfractaires se retrouvent dans les chondrites formées près du Soleil, à savoir les chondrites à enstatite.

Mais il faut cependant se garder d'interprétations trop simplistes, ne faisant intervenir que la répartition des éléments chimiques dans le disque. Les divers modèles de formation des chondrites établit par les chercheurs donnent aussi une place à des phénomènes physiques divers : turbulence du disque protoplanétaire, intervention du champ magnétique sur les métaux, vitesse orbitale des astéroïdes, etc. Si les résultats ne sont pas forcément aussi clairs que prévu à l'heure où j'écris ces lignes, il est cependant certain que chaque type de chondrite s'est formé dans des conditions bien précises, lui donnant ses particularités.

{|class=&quot;wikitable&quot;
|-
!Type de chondrite
!Lieu de formation
!Minéraux fréquents
!Composition chimique
|-
!Chondrite à enstatite
|Système solaire interne
|Enstatite, Olivine
|Riche en silicates et en métaux
|-
!Chondrite ordinaire
|Ceinture d'astéroïdes
|
|Intermédiaire
|-
!Chondrite carbonée
|Système solaire externe
|
|Riche en carbone et composés organiques
|}

Cette interprétation explique cependant bien la teneur en métaux des différentes météorites. Cette dernière forme un continuum, qui part des chondrites à enstatite pour finir aux chondrites carbonées. Les chondrites à enstatites sont de loin les plus riches en métal, alors que les chondrites carbonées sont très pauvres en métaux. Les chondrites ordinaires sont une sorte d'intermédiaire entre les deux précédentes. À ce propos, on verra d'ailleurs que les chondrites ordinaires sont elles-mêmes subdivisées en sous-classes selon leur teneur en Fer, de même que les chondrites à enstatites. On distingue ainsi, dans l'ordre de teneur décroissante, les chondrites à enstatite de type H et L, suivie par les chondrites ordinaires H, L et LL. Vu que le Fer est un élément réfractaire, ces différences de métallicité traduisent certainement la température de formation des chondrites, et donc leur lieu de naissance. Les météorites plus chargées en métal se seraient formées plus près du Soleil que les autres.

Il faut aussi noter que la température de formation n'a pas seulement influencé la teneur en métal, mais aussi son degré d'oxydation. Le Fer peut prendre deux formes différentes : une forme métallique et une forme oxydée (divers oxydes de Fer). La forme métallique se forme surtout dans un milieu réducteur, les formes oxydées se formant dans un milieu oxydant. Il faut savoir que l'oxydation du Fer augmente quand la température diminue. On devine que le degré d'oxydation des chondrites doit ainsi augmenter avec leur distance au Soleil lors de leur formation. Pour simplifier, on peut dire que le disque protoplanétaire interne (proche du Soleil) était un milieu réducteur, alors que sa partie externe était un milieu fortement oxydant. Cela explique la teneur en Fer oxydé/métallique des différentes chondrites. Les météorites carbonées sont très riches en oxydes de Fer, intégré dans des minéraux. Les chondrites à enstatite n'ont pas de Fer oxydé, tout le Fer étant contenu sous forme métallique. En clair, elles ne contiennent pas de minéraux ferreux : tout le Fer est regroupé dans des petites billes de métal, des grains métalliques. Les chondrites ordinaires sont entre les deux, avec une portion plus ou moins variable de Fer oxydé et de Fer métallique. Elles contiennent donc aussi bien des grains chondritiques métalliques que des minéraux mélangeant Fer et silicates. Les chondrites ordinaires de type H sont de loin les plus riches en Fer métallique, alors que la teneur en oxydes de Fer augmente avec les chondrites de type L, puis LL.

Mais attention : il ne faut pas prendre cette subdivision en catégories à la lettre. En réalité, l'état d'oxydation du Fer dans les météorites suit un continuum, allant des météorites au Fer totalement oxydé à des météorites au Fer totalement réduit, métallique. Même chose pour leur teneur en métal. Les diverses classes de météorites se répartissent sur ce continuum.

====Les chondrites à enstatite====

[[File:Enstatite - Kilosa District, Morogoro Region, Tanzania.jpg|vignette|Cristal d'enstatite.]]

Comme leur nom l'indique, ces chondrites contiennent un minéral nommé enstatite, un pyroxène magnésien. Elles ne contiennent pas ou peu d'olivine. Elles contiennent des traces de kamacite (un alliage de Fer et de Nickel), surtout concentré dans des grains métalliques. Les autres minéraux présents sont surtout de la troilite, ainsi que des minéraux soufrés ou nitrés. Leur composition minéralogique trahit des conditions de formation particulièrement réductrices (peu oxydantes). Cela laisse à penser que ces chondrites se sont formées près du Soleil, ce qui expliquerait aussi qu'elles sont naturellement riches en éléments réfractaires, à savoir des métaux (le Fer, notamment) et en silicates. Ces chondrites sont elles-mêmes classées en deux sous-types, en fonction de leur teneur en métal.
 
{|class=&quot;wikitable&quot;
|-
!Type
!Taille des chondres
!Taux en Fer
|-
|Chondrite EH
|Présence de mini-chondres
|Peut atteindre 35 %
|-
|Chondrite EL
|Chondres de taille moyenne
|Inférieur à 12 %
|}

====Les chondrites ordinaires====

Les '''chondrites ordinaires''' sont les plus fréquentes : plus de 80% des météorites qui tombent chaque année sont des chondrites ordinaires. Ce qui explique leur nom, au passage. Le fait qu'elles soient aussi fréquentes laisse penser que celles-ci se situent à un endroit bien précis, qui facilite leur rencontre avec la Terre. Le chercheur John Wasson a proposé que ces météorites proviennent de la ceinture d’astéroïdes, où des interactions gravitationnelles de Jupiter les dévierait de leur orbite en direction de la Terre. Scénario probable compte tenu des connaissances actuelles en mécanique céleste. Elles sont classées en trois sous-types, en fonction de leur teneur en métal.

{|class=&quot;wikitable&quot;
|-
!Classification
!Teneur en métal
!Densité
!Minéraux
|-
|Type H
|15 à 25 % de métal, surtout du Fer
|3,4 à 3,6
|Olivine, avec des traces de bronzite.
|-
|Type L
|7 à 15 %
|3,6 à 3,9
|Olivine et hypersthène.
|-
|Type LL
|3 à 7 %
|
|
|}

====Les chondrites carbonées====

Les chondrites carbonées doivent leur nom à leur teneur en carbone, largement supérieure à ce qu'on observe sur les autres chondrites. La quasi-totalité du carbone est localisée dans la matrice, ce qui lui donne une belle couleur sombre, parfois noire. La matrice carbonée prend une place très importante du volume des chondrites carbonées, pouvant aller jusqu'à 30 à 40% ! Les chondres sont un peu moins nombreux que dans les autres chondrites, alors que les inclusions réfractaires sont un peu plus fréquentes.

Les chondrites carbonées se classent en plusieurs types. Les chondrites les plus importantes de cette liste sont de loin les chondrites CI. Divers indices nous disent que ces chondrites se sont formées lors de la condensation de la nébuleuse primordiale. Notamment, celles-ci ont une composition chimique proche de celle du Soleil, et donc de la nébuleuse primordiale. Pour la plupart des éléments chimiques, la correspondance chimique et isotopique est identique à celle du Soleil, y compris pour les éléments traces ! Les éléments qui montrent une différence sont le carbone, l'hélium, l'hydrogène, l'oxygène, et l'azote. La raison est que ces éléments chimiques ne se sont pas condensés et sont restés dans la phase gazeuse de la nébuleuse. Le lithium montre aussi une petite différence, en raison de sa consommation par les réactions nucléaires solaires.

{|class=&quot;wikitable&quot;
|-
!Type
!Chondres
!Composition chimique
!Densité
|-
|Chondrite CB
|
|
|-
|Chondrite CH
|Présence de micro-chondres
|Riche en métal et en Fer, mais pauvre en éléments réfractaires.
|Variable
|-
|Chondrite CI
|Absence de chondres
|3 à 5 % de carbone, 20 % d'eau, présence de silicates hydratés, de magnétite et de sulfure
|Densité de 2,5 à 2,9
|-
|Chondrite CK
|Présence de gros chondres, silicates sombres, métal absent, beaucoup d'oxygène (rare) 
| 
|-
|Chondrite CM
| Présence de mini-chondres, 0,6 à 2,9 % de carbone, 13 % eau, débris d'olivine et de pyroxène, densité de 3,4 à 3,8
|
|-
|Chondrite CO
|Chondres de petite taille
|0,21 à 1 % de carbone, moins de 1 % d'eau.
|3,4 à 3,8
|-
|Chondrite CR
|Agglomérat de chondres liés par du carbone
|Présence d'eau assez rare, mais possible
|
|-
|Chondrite CV
|Gros chondres
|
|
|}

===L'évolution des chondrites et leur classification pétrologique===

Si la composition chimique des chondrites est identique à celle du disque protoplanétaire, leur composition minéralogique ne l'est pas. Il faut dire qu'avec les hautes températures, ces chondrites ont été métamorphisées de l'intérieur par divers phénomènes hydrothermaux et métamorphiques. De nombreux minéraux se sont alors formés par recristallisation de la matrice ou du verre des chondres. De nombreux chondres ont par exemple grossi suite à ces phénomènes, quand ils n'ont pas fusionné avec la matrice. De même, le verre des chondres a pu recristalliser, donnant des minéraux qui se démarquent de leurs voisins. Quoi qu’il en soit, les météorites qui ont conservé des grains et une matrice intacte sont exceptionnellement rares.

====Les processus d'altération/métamorphisme====

Certaines chondrites ont été le lieu d'une circulation interne de vapeur d'eau ou de fluides, qui ont altéré les chondrites. Ainsi explique-t-on la présence de minéraux argileux dans certains chondrites carbonées, alors que les minéraux hydratés n'existaient pas dans le disque. Seules les météorites carbonées sont concernées, vu que ce sont les seules à s'être formées dans un environnement riche en eau.

Sur d'autres météorites, les fortes températures ont littéralement cuit la roche, au point de la métamorphiser. De plus, les chocs avec les autres astéroïdes ont causé un métamorphisme aigu, mais suffisamment important pour entrainer la formation de minéraux de chocs (des impactites). Pour résumer, les chondrites ont vu leurs minéraux évoluer sous l'influence soit de la circulation d'eau, soit du métamorphisme (d’impact ou thermique).

====La classification pétrologique des chondrites====

Les scientifiques classent les chondrites selon l'état d'altération de la matrice et des grains, dans 7 niveaux d'altération. Cette classification a été élaborée par Wood et Van Schmus, qui ont établi une première version purement descriptive, agrémentée de quelques suppositions sur l'origine des différentes textures. Ceux-ci pensaient que les niveaux de 1 à 7 traduisaient un niveau de plus en plus important de métamorphisme. Mais il est rapidement apparu que leur interprétation était quelque peu erronée. En fait, les chondrites de type 3 sont les chondrites non-altérées par l'eau et le métamorphisme. Les météorite de type 1 et 2 ont été altérées par l'eau et l'hydrothermalisme, alors que les types 4 à 7 ont été métamorphisés.

{|class=&quot;wikitable&quot; style=&quot;text-align:center&quot;
|-
!Type pétrographique
! 1 et 2
! 3
! 4, 5, 6 et 7
|-
!Processus d'altération
| Altération aqueuse
| Aucun
| Métamorphisme
|-
!Intensité de l’altération
| &lt;math&gt; \leftarrow&lt;/math&gt;
| Nulle
| &lt;math&gt; \rightarrow&lt;/math&gt;
|-
! Chondrites concernées
| Carbonées uniquement
| Tout type possible
| Ordinaires ou à enstatite
|}

==Les météorites différenciées==

Certaines météorites proviennent de corps qui ont subi une fusion partielle après leur formation, leur donnant l'occasion de se différencier. Dans les grandes lignes, on distingue les météorites primitives et évoluées. Les '''météorites primitives''' sont le résultat d'une différentiation incomplète, à savoir que leur roche a partiellement fondu, mais sans pour autant que les métaux se séparent des silicates. Elles ont donc une composition chimique identique à celle des chondrites, mais la texture et leur aspect en diffère radicalement. Les chondres ont disparu, de même que les autres grains chondritiques : tous se sont mélangés avec la matrice. Formellement, ce sont toutes des achondrites, à savoir des météorites pierreuses riches en silicates. Les '''météorites évoluées''' sont le résultat d'une différentiation assez marquée, les silicates s'étant séparés des métaux. Elles proviennent donc d'un corps parent qui a eu le temps de se séparer en un manteau silicaté et un noyau métallique. On peut classer ces météorites différenciées en trois types, selon qu'elles proviennent du manteau, du noyau ou de l'interface noyau-manteau. Les météorites mantelliques sont des achondrites intégralement composées de silicates, appelées des achondrites évoluées. Les morceaux de noyau donnent des sidérites, des météorites purement ferreuses, riches en Fer et en Nickel. Enfin, les météorites formées à la limite entre le manteau et le noyau, les lithosidérites, sont composées de métaux ferreux et de silicates mélangés.

Il faut savoir que ces météorites se sont formées en se détachant du corps originel, à cause d'un impact planétaire ou d'une collision entre astéroïdes. Les scientifiques ont classé les météorites en fonction de leur composition chimique, de leur mécanisme de formation (évoluées ou primitives), mais aussi de leur corps parent. Ils ont placé la composition chimique en premier lieu, avant de subdiviser les catégories obtenues selon leur mécanisme de formation, puis leur corps parent. On distingue ainsi les météorites pierreuses (achondrites), ferreuses et intermédiaires. C’est cette classification que nous allons reprendre ci-dessous.

===Les achondrites===

[[File:Nakhlitoszlop.JPG|vignette|Structure d'une Nakhlite.]]

Les achondrites se classent en plusieurs types, qui différent par leur composition chimique et isotopique. Les achondrites évoluées se distinguent des achondrites primitives par la présence ou l'absence de métaux dans leur composition chimique. Les achondrites évoluées sont très pauvre en métaux, ceux-ci ayant migré dans le noyau. À l'inverse, le métal n'a pas eu l’occasion de se séparer totalement des silicates, ce qui fait que les achondrites primitives sont assez riches en métaux, presque autant que les chondrites.

====Les achondrites primitives====

Les achondrites primitives se classent en plusieurs sous-types, mais sans que cela ne permette de distinguer avec certitude leur corps parent. On distingue les ureilites, les brachinites, les winonaïtes, les acapulcoïtes et les lodranites. La grande partie sont riches en minéraux silicatés, le plus commun étant de loin d'olivine, secondée par des pyroxènes, du ferronickel et de la troilite.

{|class=&quot;wikitable&quot;
|+ Météorites primitives
|-
!Type
!Composition minéralogique et chimique
|-
!Acapulcoïte et lodranite
|Riches en olivine et en pyroxène, avec du plagioclase, du ferronickel et de la troilite. La différence entre les deux tient dans la taille des minéraux, leur granulométrie. Les acapulcoïtes ont des minéraux reliques plus gros que pour les lodranites.
|-
!Winonaïte
|Riches en olivine magnésienne, pyroxènes, avec un peu de ferronickel et de troilite.
|-
!Brachinite
|Riches en olivine et en pyroxène, avec du plagioclase et de la troilite.
|-
!Uréilite
|Riches en olivine et pigeonite, avec présence plus rare de clinopyroxène et de diamants. Pauvre en calcium, mais riche en carbone, Fer et Nickel.
|}

====Les achondrites évoluées====

Leur composition isotopique indique que ces météorites sont assez jeunes, en tout moins que le système solaire. De plus, ces météorites sont formées de roches magmatiques, ce qui montre qu'elles sont des morceaux de corps telluriques suffisamment gros pour avoir eu du volcanisme, ou au moins une forme de différentiation suffisante. Ces deux points montrent que ces météorites viennent d'une planète ou d'un très gros astéroïde. On sait aujourd'hui, par divers arguments isotopiques ou chimiques, que certaines achondrites évoluées proviennent de la Lune, d'autres de Mars et d'autres d'un astéroïde appelée Vesta. n distingue donc les achondrites lunaires, martiennes et vestales. Les météorites martiennes et lunaires sont donc classées dans les achondrites, au même titre que des météorites provenant d’astéroïdes plus petits (l’astéroïde Vesta, par exemple).

Les '''météorites SNC''' sont clairement les mieux connues à l'heure actuelle. Ces météorites sont nommées sous le terme de météorites SNC, du nom des trois météorites les plus typiques de cette classe : celle de Shergotty (Inde, 1865), Nkhla (Égypte, 1911) et Chassigny (France, 1815). Depuis, deux autres types de météorites martienne ont été découverts. Un point intéressant est leur composition isotopique en oxygène, bien trop différente de celle de la Terre ou de la Lune. Ce qui montre que celles-ci sont nées sur d'autres corps telluriques, les seuls candidats restants étant les astéroïdes, Mercure, Mars et Venus. Vu l’épaisseur et la densité de l'atmosphère vénusienne, il est peu probable que des morceaux de la croûte aient pu s'en enfuir sans être freinés par l'air. Mercure est aussi improbable : si un morceau de la planète dégage dans l'espace, il a de fortes chances d'être attiré par le Soleil que de s'en éloigner en direction de la Terre. Mars n'a pas ce problème : la gravité du Soleil a toutes les chances d'attirer l'astéroïde vers la Terre. L'ultime confirmation provint des analyses de la surface et de l'atmosphère martienne par la sonde Viking, qui montra la correspondance entre ces mesures et les météorites SNC.

{|class=&quot;wikitable&quot;
|+ Météorites martiennes
|-
!Type/provenance
!Sous-types
!Composition minéralogique
|-
| rowspan=&quot;3&quot; | Météorites SNC
|Shergottites
|Basaltes riches en augite et pigeonite, qui contiennent beaucoup de cristaux de Feldspaths.
|-
|Nakhlites
|Basaltes riches en Augite et en pyroxènes.
|-
|Chassignites
|Basaltes extrêmement riches en olivine : plus de 99% de ces météorites sont en olivine.
|}

Si l'on met de côté les météorites lunaires et martiennes (SNC), il ne reste que des '''météorites astéroïdales''', c'est à dire provenant d'astéroïdes. Les plus connues sont de loin les '''météorites HED''', supposées provenir de l’astéroïde Vesta. Ces météorites sont au nombre de trois sous-types : les Howardites, les Eucrites et les Diogénites. Elles doivent leur nom à la présence de certains minéraux : de l'howardite, de l'eucrite ou de la diogénite selon le type. Les eucrites sont de nature basaltique, le terme eucrite désignant d'ailleurs le gabbro, une roche basaltique. Elles semblent avoir refroidit assez rapidement, ce qui témoignerait d'une origine volcanique, ou tout du moins d'un refroidissement plutonique peu profond. Le contraste est assez marqué avec les diogènites, qui semble avoir une nature plutonique plus profonde. Quant aux howardites, ce sont des brèches qui mélangent des morceaux d'eucrites et de diogènites, vraisemblablement formées lors d'impacts. Les autres météorites astéroïdales sont classées en plusieurs sous-types qui portent les noms d''''Angrite''' et '''Aubrite'''.

{|class=&quot;wikitable&quot;
|+ Météorites astéroidales
|-
!Type
!Provenance
!Sous-types
!Composition minéralogique
!Composition chimique
|-
| rowspan=&quot;3&quot; | Météorites HED
| rowspan=&quot;3&quot; | Astéroïde Vesta
|Eucrites
|Basalte riche en eucrite (qui donne le nom à la météorite), pigeonite, pyroxène et plagioclase.
|
|-
|Diogénites.
|Riches en diogénite, pyroxènes, avec de plus faibles part d'olivine et de plagioclase.
|Riche en magnésium.
|-
|Howardites
|Brèches, riches en un minéral nommé Howardite.
|
|-
|Angrite
|Inconnu.
|Aucun.
|Riches en un minéral nommé Augite (à près de 90%), avec beaucoup de pyroxènes calcique, de troïlite, d'olivine et d'anorthite.
|
|-
|Aubrite
|Inconnu.
|Aucun.
|Riche en enstatite.
|Constituée majoritairement de silice et de magnésie, absence de calcium.
|}

===Les sidérites===

[[File:Meteoric iron phase diagram taenite kamacite.svg|vignette|Diagramme de phase de la taénite et de la kamacite.]]

Les sidérites sont essentiellement composées de Fer et de Nickel, ainsi que d'autres minéraux dits sidérophiles (qui se lient chimiquement avec le Fer). L'alliage de Fer et de Nickel forme des minéraux appelés '''kamacite''' et '''taénite'''. La taénite est riche en Nickel, alors que la kamacite est pauvre en Nickel. Leurs teneurs varient fortement selon les conditions de formation de la météorite. Le diagramme à votre droite montre dans quelles conditions se forment ces deux minéraux. On voit que la kamacite se forme préférentiellement quand la teneur en Nickel est très faible et les températures faibles. À des températures plus élevées et/ou des teneurs en Nickel plus fortes, la taenite fait son apparition et se forme en même temps que la kamacite. Ce n'est qu'à des teneurs assez fortes en Nickel ou des températures très élevées que la taénite se forme exclusivement et que la kamacite disparaît. On peut donc deviner que les teneurs en kamacite et en taénite indiquent dans quelles conditions thermiques et chimiques s'est formée une météorite. Vu que les météorites ferreuses se sont formées à des températures supposées similaires, on devine que les ces teneurs dépendent de la vitesse de refroidissement de la météorite. Plus la météorite refroidit lentement, plus la kamacite prend de l'importance par rapport à la taénite.

====La classification structurale des sidérites====

La classification des sidérites est plus complexe que pour les autres classes de météorites. Il faut dire que deux classifications sont utilisées : une qui se base sur la composition chimique et une qui se base sur la présence d'isotopes précis. La '''classification structurale''' des sidérites se base sur leur composition chimique et éventuellement leur texture. La raison à cela est que la texture formée dépend de la teneur en métaux et de leurs proportions. Les chercheurs classent les sidérites en trois classes, selon leurs teneurs en Nickel : les hexaédrites pauvres en Nickel, les octahédrites intermédiaires et les ataxites très riches en Nickel.

{|
|[[File:Meteoric iron phase diagram taenite kamacite hexahedrite.svg|vignette|Hexahédrites.]]
|[[File:Meteoric iron phase diagram taenite kamacite octaehedrite.svg|vignette|Octahédrite.]]
|[[File:Meteoric iron phase diagram taenite kamacite ataxite.svg|vignette|Ataxite.]]
|}

[[File:TolucaMeteorite.jpg|vignette|upright=2.0|Figures de Widmanstätten]]

Les octaédrites se distinguent des autres classes par leur aspect, leur texture. Celle-ci est souvent dominé par ce qu'on appelle les '''figures de Widmanstätten''', illustrées ci-dessous. Ces figures se révèlent le plus souvent après polissage ou attaque à l'acide de la météorite. Elles se forment lors du refroidissement de la météorite, quand l'alliage de Fer et de Nickel qui compose la météorite se sépare en taénite  et kamacite. La taénite correspond aux bandes mates, alors que la kamacite correspond aux bandes brillantes. L’épaisseur des bandes de Kamacite permet de classer arbitrairement les octaédrites en plusieurs sous-classes, allant des bandes les plus fines aux bandes les plus larges.

====La classification chimique moderne des sidérites====

De nos jours, la classification structurale des sidérites est remplacée par une '''classification chimique''', basée sur la teneur en éléments traces comme le Gallium, le Germanium et l'Iridium. Cette classification distingue un grand nombre de catégories, 14 au total, avec quelques sous-catégories. Il est supposé que les météorites d'une même catégories proviennent d'un même corps parent. La classification chimique a été revue un grand nombre de fois. La première version ne distinguait que 4 classes, qui ont par la suite été découpées en sous-catégories, et ainsi de suite.

===Les litho-sidérites===

On peut classer les litho-sidérites en deux grands types : les pallasites et les mésosidérites. Les '''pallasites''', composées de cristaux d'olivine plongés dans une matrice métallique, qui se sont vraisemblablement formées entre le manteau et le noyau. Enfin, les '''mésosidérites''' ont une origine plus incertaine.

&lt;noinclude&gt;
{{NavChapitre | book=Planétologie
           | prev=Les satellites de Saturne
           | prevText=Les satellites de Saturne
           | next=Les astéroïdes
           | nextText=Les astéroïdes
}}{{AutoCat}}
&lt;/noinclude&gt;</text>
      <sha1>fse3rz3vlffbpyiy65gbk56gjeual1q</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/Les circuits de sélection</title>
    <ns>0</ns>
    <id>70056</id>
    <revision>
      <id>684223</id>
      <parentid>679647</parentid>
      <timestamp>2022-08-27T12:27:51Z</timestamp>
      <contributor>
        <ip>37.170.78.245</ip>
      </contributor>
      <comment>/* Le démultiplexeur */</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="28546" xml:space="preserve">Dans les chapitres précédents, nous avons vu comment fabriquer des circuits relativement généraux. Il est maintenant temps de voir quelques circuits relativement simples, très utilisés. Ces circuits simples sont utilisés pour construire des circuits plus complexes, comme des processeurs, des mémoires, et bien d'autres. Les prochains chapitres vont se concentrer exclusivement sur ces circuits simples, mais courants. Nous allons donner quelques exemples de circuits assez fréquents dans un ordinateur et voir comment construire ceux-ci avec des portes logiques. Dans ce chapitre, nous allons nous concentrer sur quelques circuits, que j'ai décidé de regrouper sous le nom de '''circuits de sélection'''. Les circuits que nous allons présenter sont utilisés dans les mémoires, ainsi que dans certains circuits de calcul. Il est important de bien mémoriser ces circuits, ainsi que la procédure pour les concevoir : nous en aurons besoin dans la suite du cours. Ils sont au nombre de quatre : le décodeur, l'encodeur, le multiplexeur et le démultiplexeur.

==Le décodeur==

[[File:DECODER 3 vers 8.png|vignette|Décodeur à 3 entrées et 8 sorties.]]

Le premier circuit que nous allons voir est le '''décodeur''', un composant qui contient  un grand nombre d'entrées et de sorties, avec des sorties qui sont numérotées. Un décodeur possède une entrée sur laquelle on envoie un nombre codé &lt;math&gt;N&lt;/math&gt; bits et &lt;math&gt;2^N&lt;/math&gt; sorties de 1 bit. Par exemple, un décodeur avec une entrée de 2 bits aura 4 sorties, un décodeur avec une entrée de 3 bits aura 8 sorties, un décodeur avec une entrée de 8 bits aura 256 sorties, etc. Généralement, on précise le nombre de bits d'entrée et de sortie comme suit : on parle d'un décodeur X vers Y pour X bits d'entrée et Y de sortie. Ce qui fait qu'on peut parler de décodeur 3 vers 8 pour un décodeur à 3 bits d'entrée et 8 de sortie, de décodeur 4 vers 16, etc.

Le fonctionnement d'un décodeur est très simple : il prend sur son entrée un nombre entier x codé en binaire, puis il positionne à 1 la sortie numérotée x et met à zéro toutes les autres sorties. Par exemple, si on envoie la valeur 6 sur ses entrées, il mettra la sortie numéro 6 à 1 et les autres à zéro.

Pour résumer, un décodeur est un circuit :
* avec une entrée de &lt;math&gt;N&lt;/math&gt; bits ;
* avec &lt;math&gt;2^N&lt;/math&gt; sorties de 1 bit ;
* où les sorties sont numérotées en partant de zéro ;
* où on ne peut sélectionner qu'une seule sortie à la fois : une seule sortie devra être placée à 1, et toutes les autres à zéro ;
* et où deux nombres d'entrée différents devront sélectionner des sorties différentes : la sortie de notre contrôleur qui sera mise à 1 sera différente pour deux nombres différents placés sur son entrée.

===La table de vérité d'un décodeur===

Au vu de ce qui vient d'être dit, on peut facilement écrire la table de vérité d'un décodeur. Pour l'exemple, prenons un décodeur 2 vers 4, pour simplifier la table de vérité. Voici sa table de vérité complète, c’est-à-dire qui contient toutes les sorties regroupées :

{|class=&quot;wikitable&quot;
|-
! E0 !! E1 !! !! S0 !! S1 !! S2 !! S3
|-
| 0 || 0 || || 1 || 0 || 0 || 0
|-
| 0 || 1 || || 0 || 1 || 0 || 0
|-
| 1 || 0 || || 0 || 0 || 1 || 0
|-
| 1 || 1 || || 0 || 0 || 0 || 1
|}

Vous remarquerez que la table de vérité est assez spéciale. Les seuls bits à 1 sont sur la diagonale. Et cela ne vaut pas que dans l'exemple choisit, mais cela se généralise pour tous les décodeurs. Cela se voit aussi quand on prend le tableau de Karnaugh d'un décodeur : il n'y a qu'un seul bit à 1 dans le tableau correspondant à une sortie.

[[File:Karnaugh map KV 1-aus-n-Decoder.svg|centre|vignette|upright=2|Tableau de Karnaugh d'un décodeur 2 vers 4.]]

Sur chaque ligne, il n'y a qu'un seul bit à 1, ce qui traduit le fait qu'une entrée ne met qu'une seule sortie est à 1 et met les autres à 0. Si on traduit la table de vérité sous la forme d'équations logiques et de circuit, on obtient ceci :

[[File:Decoder Example.svg|centre|vignette|upright=2|Equations logiques et circuit d'un décodeur 2 vers 4.]]

Il y a des choses intéressantes à remarquer sur les équations logiques. Pour rappel, l'équation logique d'une sortie est composée, dans le cas général, soit d'un minterm unique, soit d'un OU entre plusieurs minterms. Chaque minterm est l'équation d'un circuit qui compare l'entrée à un nombre bien précis et dépendant du minterm. Si on regarde bien, l'équation de chaque sortie correspond à un minterm et à rien d'autre, il n'y a pas de OU entre plusieurs minterms. Les minterms sont de plus différents pour chaque sortie et on ne trouve pas deux sorties avec le même minterm. Enfin, chaque minterm possible est présent : X bits d'entrée nous donnent 2^X entrées différentes possibles, donc 2^X minterms possibles. Et il se trouve que tous ces minterms possibles sont représentés dans un décodeur, ils ont tous leur sortie associée. C'est une autre manière de définir un décodeur : toutes ses sorties codent un minterm, deux sorties différentes ont des minterms différents et tous les minterms possibles sur n bits sont représentés.

Ces informations vont nous être utiles pour la suite. En effet, grâce à elles, nous allons en déduire une méthode générale pour fabriquer un décodeur, peu importe son nombre de bits d'entrée et de sortie. Mais elles permettent aussi de montrer que l'on peut créer n'importe quel circuit combinatoire quelconque à partir d'un décodeur et de quelques portes logiques. Dans ce qui suit, on suppose que le circuit combinatoire en question a une entrée de n bits et une seule sortie de 1 bit. Pour rappel, ce genre de circuit se conçoit en utilisant une table de vérité qu'on traduit en équations logiques, puis en circuits. Le circuit obtenu est alors soit un simple minterm, soit un OU entre plusieurs minterms. Or, le décodeur contient tous les minterms possibles pour une entrée de n bits, avec un minterm par sortie. Il suffit donc de prendre une porte OU et de la connecter aux minterms/sorties adéquats.

[[File:Conception d'un circuit combinatoire quelconque à partir d'un décodeur.jpg|centre|vignette|upright=2|Conception d'un circuit combinatoire quelconque à partir d'un décodeur.]]

Ceci étant dit, passons à la conception d'un décodeur avec des portes logiques.

===L'intérieur d'un décodeur===

On vient de voir que chaque sortie d'un décodeur correspond à son propre minterm, et que tous les minterms possibles sont représentés. Rappelons que chaque minterm est associé à un circuit qui compare l'entrée à une constante X, X dépendant du minterm. En combinant ces deux informations, on devine qu'un décodeur est simplement composé de comparateurs avec une constante que de minterms/sorties. Par exemple, si je prends un décodeur 7 vers 128, cela veut dire qu'on peut envoyer en entrée un nombre codé entre 0 et 127 et que chaque nombre aura son propre minterm associé : il y aura un minterm qui vérifie si l'entrée vaut 0, un autre vérifie si elle vaut 1, un autre qui vérifie si elle vaut 2, ... , un minterm qui vérifie si l'entrée vaut 126, et enfin un minterm qui vérifie si l'entrée vaut 127.

Pour reformuler d'une manière bien plus simple, on peut voir les choses comme suit. Si l'entrée du décodeur vaut N, la sortie mise à 1 est la sortie N. Bref, déduire quand mettre à 1 la sortie N est facile : il suffit de comparer l'entrée avec N. Si l'adresse vaut N, on envoie un 1 sur la sortie, et on envoie un zéro sinon. Pour cela, j'ai donc besoin d'un comparateur pour chaque sortie, et le tour est joué. Précisons cependant que cette méthode gaspille beaucoup de circuits et qu'il y a une certaine redondance. En effet, les comparateurs ont souvent des portions de circuits qui sont identiques et ne diffèrent parfois que ce quelques portes logiques. En utilisant des comparateurs séparés, ces portions de circuits sont dupliquées, alors qu'il serait judicieux de partager.

[[File:Internals of decoder.png|centre|vignette|upright=1.5|Exemple d'un décodeur à 8 sorties.]]

Comme autre méthode, plus économe en circuits, on peut créer un décodeur en assemblant plusieurs décodeurs plus simples, nommés sous-décodeurs. Ces sous-décodeurs sont des décodeurs normaux, auxquels on a ajouté une entrée RAZ, qui permet de mettre à zéro toutes les sorties : si on met un 0 sur cette entrée, toutes les sorties passent à 0, alors que le décodeur fonctionne normalement sinon. Construire un décodeur demande suffisamment de sous-décodeurs pour combler toutes les sorties. Si on utilise des sous-décodeurs à n entrées, ceux-ci prendront en entrée les n bits de poids faible de l'entrée du décodeur que l'on souhaite construire (le décodeur final). Dans ces conditions, les n décodeurs auront une de leurs sorties à 1. Pour que le décodeur final se comporte comme il faut, il faut désactiver tous les sous-décodeurs, sauf un avec l'entrée RAZ. Pour commander les n bits RAZ des sous-décodeurs, il suffit d'utiliser un décodeur qui est commandé par les bits de poids fort du décodeur final.

[[File:Décodeur 3 vers 8 conçu à partir de décodeurs 2 vers 4.jpg|centre|vignette|upright=1.5|Décodeur 3 vers 8 conçu à partir de décodeurs 2 vers 4.]]

==L'encodeur==

[[File:8 to 3 simple encoder IEC symbol.svg|vignette|upright=0.5|Encodeur à 8 entrées (et 3 sorties).]]

Il existe un circuit qui fait exactement l'inverse du décodeur : c'est l''''encodeur'''. Là où les décodeurs ont une entrée de &lt;math&gt;N&lt;/math&gt; bits et &lt;math&gt;2^N&lt;/math&gt; sorties de 1 bit, l'encodeur a à l'inverse &lt;math&gt;2^N&lt;/math&gt; entrées de 1 bit avec une sortie de &lt;math&gt;N&lt;/math&gt; bits. Par exemple, un encodeur avec une entrée de 4 bits aura 2 sorties, un décodeur avec une entrée de 8 bits aura 3 sorties, un décodeur avec une entrée de 256 bits aura 8 sorties, etc. Comme pour les décodeurs, on parle d'un encodeur X vers Y pour X bits d'entrée et Y de sortie. Ce qui fait qu'on peut parler de décodeur 8 vers 3 pour un décodeur à 8 bits d'entrée et 3 de sortie, de décodeur 16 vers 4, etc.

[[File:Encoder block diagram.jpg|centre|vignette|upright=1.5|Entrées et sorties d'un encodeur.]]

De plus, contrairement au décodeur, ce sont les entrées qui sont numérotées de 0 à N et non les sorties. Dans ce qui suit, on va supposer qu'une seule des entrées est à 1. En sortie, l'encodeur donne le numéro de l'entrée qui est à 1. Par exemple, si l'entrée numéro 5 est à 1 et les autres à 0, alors l'encodeur envoie un 5 sur sa sortie.

===L'encodeur 4 vers 2===

Prenons l'exemple d'un encodeur à 4 entrées et 2 sorties. Écrivons sa table de vérité. D'après la description du circuit, on devrait trouver ceci :

{|class=&quot;wikitable&quot;
|+ Table de vérité d'un encodeur 4 vers 2
|-
! E3 !! E2 !! E1 !! E0 !! !! S1 !! S0
|-
| 0 || 0 || 0 || 1 || || 0 || 0
|-
| 0 || 0 || 1 || 0 || || 0 || 1
|-
| 0 || 1 || 0 || 0 || || 1 || 0
|-
| 1 || 0 || 0 || 0 || || 1 || 1
|}

Vous voyez que la table de vérité est incomplète. En effet, l'encodeur fonctionne tant qu'une seule de ses entrées est à 1. L'encodeur dit alors quelle est la sortie à 1, mais cela suppose que les autres soient à 0. Si plusieurs entrées sont à 1, le comportement de l'encodeur est à préciser. Mais passons cela sous silence et ne tenons compte que de la table de vérité partielle précédente. On peut traduire cette table de vérité en circuit logique. On obtient alors les équations suivantes :

: &lt;math&gt;S1 = E3 + E2&lt;/math&gt;

: &lt;math&gt;S0 = E3 + E1&lt;/math&gt;

Le tout donne le circuit suivant :

[[File:A Simple 4-2 encoder using or gate.jpg|centre|vignette|upright=1.5|Exemple d'encodeur à 4 entrées et 2 sorties.]]

===Les encodeurs à plus de deux sorties===

Il est possible de créer un encodeur complexe en combinant plusieurs encodeurs simples. C'est un peu la même chose qu'avec les décodeurs, pour lesquels on peut créer un décodeur 8 vers 256 à base de deux décodeurs 7 vers 128, ou de quatre décodeurs 6 vers 64. L'idée de découper le nombre d'entrée en morceaux séparés, chaque morceau étant traité par un encodeur à priorité distinct des autres. Les résultats des différents encodeurs sont ensuite combinés pour donner le résultat final.

Pour comprendre l'idée, prenons la table de vérité d'un encodeur 8 vers 3; donnée dans le tableau ci-dessous. 

{|class=&quot;wikitable&quot;
|+ Table de vérité d'un encodeur 8 vers 3
|-
! E7 !! E6 !! E5 !! E4 !! E3 !! E2 !! E1 !! E0 !! !! S2 !! S1 !! S0
|-
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || || 0 || 0 || 0
|-
| 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || || 0 || 0 || 1
|-
| 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || || 0 || 1 || 0
|-
| 0 || 0 || 0 || 0 || 1 || 0 || 0 || 0 || || 0 || 1 || 1
|-
| 0 || 0 || 0 || 1 || 0 || 0 || 0 || 0 || || 1 || 0 || 0
|-
| 0 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || || 1 || 0 || 1
|-
| 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || || 1 || 1 || 0
|-
| 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || || 1 || 1 || 1
|}

En regardant bien, vous verrez que vous pouvez trouver la table de vérité d'un encodeur 4 vers 2 en deux exemplaires, indiquées en rouge.

{|class=&quot;wikitable&quot;
|+ Table de vérité d'un encodeur 8 vers 3
|-
! E7 !! E6 !! E5 !! E4 !! E3 !! E2 !! E1 !! E0 !! !! S2 !! S1 !! S0
|-
| 0 || 0 || 0 || 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 ||
| 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0
|-
| 0 || 0 || 0 || 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 ||
| 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1
|-
| 0 || 0 || 0 || 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 ||
| 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0
|-
| 0 || 0 || 0 || 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 ||
| 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 1
|-
| bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || 0 || 0 || 0 || 0 ||
| 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0
|-
| bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || 0 || 0 || 0 || 0 ||
| 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1
|-
| bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || 0 || 0 || 0 || 0 ||
| 1 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0
|-
| bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || 0 || 0 || 0 || 0 ||
| 1 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 1
|}

On voit que les deux bits de poids faibles correspondent à la sortie de l'encodeur activé par l'entrée. Si le premier encodeur est activé, c'est lui qui fournit les bits de poids faibles. Inversement, si c'est le second encodeur qui a un résultat non-nul, c'est lui qui fournit les bits de poids faible. Notons que seul un des deux encodeurs a une sortie non-nulle à la fois : soit le premier a une sortie non-nulle, soit c'est le second, mais c'est impossible que ce soit les deux en même temps. Cela permet de déduire quelle opération permet de mixer les deux résultats : un simple OU logique suffit. Car, pour rappel, 0 OU X donne X, quelque que soit le X en question. Les bits de poids faible du résultat se calculent en faisant un OU entre les deux résultats des encodeurs.

Ensuite, il faut déterminer comment fixer le bit de poids fort du résultat. Il vaut 0 si le premier encodeur a une entrée non-nulle, et 1 si c'est le premier encodeur qui a une entrée non-nulle. Pour cela, il suffit de vérifier si les bits de poids forts, associés au premier encodeur, contiennent un 1. Si c'est le cas, alors on met la troisième sortie à 1.

[[File:Encodeur fabriqué à partir d'encodeurs plus petits.png|centre|vignette|upright=2|Encodeur fabriqué à partir d'encodeurs plus petits.]]

Notons que cette procédure, à savoir faire un OU entre les sorties de deux encodeurs simples, puis faire un OU pour calculer le troisième bit, marche pour tout encodeur de taille quelconque. A vrai dire, le circuit obtenu plus haut d'un encodeur 4 vers 2 est conçu ainsi, mais en combinant deux encodeurs 2 vers 1.

La procédure consiste à ajouter trois portes OU à deux encodeurs. Mais ceux-ci sont eux-même composés de portes OU associées à des encodeurs plus petits, et ainsi de suite. On peut poursuivre ainsi jusqu’à tomber sur des encodeurs 4 vers 2, qui sont eux-mêmes composés de deux portes OU. Au final, on se retrouve avec un circuit conçu uniquement à partir de portes OU. Notons qu'il est possible de simplifier le circuit obtenu avec la procédure en fusionnant des portes OU. Si on simplifie vraiment au maximum, le circuit consiste alors en une porte OU à plusieurs entrées par sortie, chacune étant connectée à certaines entrées bien précises. Pour un encodeur 8 vers 3, la simplification du circuit devrait donner ceci :

[[File:8-3 Encoder.gif|centre|vignette|upright=1.5|Encodeur 8 vers 3.]]

==Le multiplexeur==

Les décodeurs ont des cousins : les multiplexeurs. Ces multiplexeurs sont des composants qui possèdent un nombre variable d'entrées et une sortie. Le rôle d'un multiplexeur est de recopier le contenu d'une des entrées sur sa sortie. Bien sûr, il faut bien choisir l'entrée qu'on veut recopier sur la sortie : pour cela, notre multiplexeur contient une entrée de commande qui permet de spécifier quelle entrée doit être recopiée.

[[File:4-to-1 multiplexer.svg|centre|vignette|Multiplexeur à 4 entrées.]]

===Le multiplexeur à deux entrées===

Le multiplexeur le plus simple est le multiplexeur à deux entrées et une sortie. Il est facile de le construire avec des portes logiques, dans les implémentations les plus simples. Sachez toutefois que les multiplexeurs utilisés dans les ordinateurs récents ne sont pas forcément fabriqués avec des portes logiques, mais qu'on peut aussi les fabriquer directement avec des transistors.

[[File:Multiplexeur à deux entrées - symbole.png|centre|vignette|upright=1.5|Multiplexeur à deux entrées - symbole.]]

Pour commencer, établissons sa table de vérité. On va supposer qu'un 0 sur l'entrée de commande sélectionne l'entrée a. La table de vérité devrait être la suivante :

{|class=&quot;wikitable&quot;
|-
!Entrée de commande
!Entrée a
!Entrée b
!Sortie
|-
|0||0||0||0
|-
|0||0||1||0
|-
|0||1||0||1
|-
|0||1||1||1
|-
|1||0||0||0
|-
|1||0||1||1
|-
|1||1||0||0
|-
|1||1||1||1
|}

Sélectionnons les lignes qui mettent la sortie à 1 :

{|class=&quot;wikitable&quot;
|-
!Entrée de commande
!Entrée a
!Entrée b
!Sortie
|-
|0||1||0||1
|-
|0||1||1||1
|-
|1||0||1||1
|-
|1||1||1||1
|}

On sait maintenant quels comparateurs avec une constante utiliser. On peut, écrire l'équation logique du circuit. La première ligne donne l'équation suivante : &lt;math&gt;\overline{E_c} . a . \overline{b}&lt;/math&gt;, la seconde donne l'équation &lt;math&gt;\overline{E_c} . a . b&lt;/math&gt; , la troisième l'équation &lt;math&gt;E_c . \overline{a} . b&lt;/math&gt; et la quatrième l'équation &lt;math&gt;E_c . a . b&lt;/math&gt;. L'équation finale obtenue est donc :

: &lt;math&gt;(\overline{E_c} . a . \overline{b}) + (\overline{E_c} . a . b) +  (E_c . \overline{a} . b) + E_c . a . b&lt;/math&gt;

L'équation précédente est assez compliquée, mais il y a moyen de la simplifier assez radicalement. Pour cela, nous allons utiliser les règles de l’algèbre de Boole. Pour commencer, nous allons factoriser &lt;math&gt;(\overline{E_c}&lt;/math&gt; et &lt;math&gt;E_c&lt;/math&gt; :

: &lt;math&gt; \left[ \overline{E_c} .[ (a . \overline{b}) + (a . b)] \right] + \left[ E_c . [(\overline{a} . b) + (a . b)] \right] &lt;/math&gt;

Ensuite, factorisons &lt;math&gt;a&lt;/math&gt; dans le premier terme et &lt;math&gt;b&lt;/math&gt; dans le second :

: &lt;math&gt; \left[ \overline{E_c} . a . (\overline{b} + b) \right] + \left[ E_c . b . (\overline{a} + a) \right]&lt;/math&gt;

Les termes &lt;math&gt;\overline{b} + b&lt;/math&gt; et &lt;math&gt;\overline{a} + a&lt;/math&gt; valent 1 :

: &lt;math&gt; \left[ \overline{E_c} . a . 1 \right] + \left[ E_c . b . 1 \right]&lt;/math&gt;

On sait que &lt;math&gt;a . 1 = a&lt;/math&gt;, ce qui fait que l'équation simplifiée est la suivante :

: &lt;math&gt;(\overline{E_c} . a) +  (E_c . b)&lt;/math&gt;

Le circuit qui correspond est :

[[File:Multiplexeur à deux entrées - circuit.png|centre|vignette|upright=1.5|Multiplexeur à deux entrées - circuit.]]

===Les multiplexeurs à plus de deux entrées===

Il est possible de concevoir un multiplexeur quelconque à partir de sa table de vérité. Le résultat est alors un circuit composé d'une porte OU à plusieurs entrées, de plusieurs portes ET, et de quelques portes NON. Un exemple est illustré ci-dessous. Vous remarquerez cependant que ce circuit a un défaut : la porte OU finale a beaucoup d'entrées, ce qui pose de nombreux problèmes techniques. Il est difficile de concevoir des portes logiques avec un très grand nombre d'entrées. Aussi, les applications à haute performance demandent d'utiliser d'autres solutions.

[[File:Mux2.png|centre|vignette|upright=1.5|Multiplexeur conçu à partir de sa table de vérité.]]

Une solution alternative est de concevoir un multiplexeur à plus de deux entrées en combinant des multiplexeurs plus simples. Par exemple, en prenant deux multiplexeurs plus simples, et en ajoutant un multiplexeur 2 vers 1 sur leurs sorties respectives. Le multiplexeur final se contente de sélectionner une sortie parmi les deux sorties des multiplexeurs précédents, qui ont déjà effectué une sorte de présélection.

[[File:Multiplexeur conçu à partir de multiplexeurs plus simples.jpg|centre|vignette|upright=1.5|Multiplexeur conçu à partir de multiplexeurs plus simples.]]

Il existe toutefois une manière bien plus simple pour créer des multiplexeurs : il suffit d'utiliser un décodeur, quelques portes OU, et quelques portes ET. L'idée est de :
* sélectionner l'entrée à recopier sur la sortie ;
* mettre les autres entrées à zéro ;
* faire un OU entre toutes les entrées : vu que toutes les entrées non-sélectionnées sont à zéro, la sortie de la porte OU aura la même valeur que l'entrée sélectionnée.

Pour sélectionner l'entrée adéquate du multiplexeur, on utilise un décodeur : si la sortie n du décodeur est à 1, alors l'entrée numéro n du multiplexeur sera recopiée sur sa sortie. Dans ces conditions, l'entrée de commande du multiplexeur correspond à l'entrée du décodeur. Pour mettre à zéro les entrées non-sélectionnées, on ajoute une porte ET par entrée : vu que a.0=0 et a.1=a, la porte ET :
* recopie l'entrée du multiplexeur si le décodeur sort un 1 ;
* met à zéro l'entrée si le décodeur sort un 0.

[[File:Multiplexeur 2 vers 4 conçu à partir d'un décodeur.png|centre|vignette|upright=1.5|Multiplexeur 2 vers 4 conçu à partir d'un décodeur.]]

Une autre manière d’expliquer le circuit précédent est d'utiliser la notion de masque vue au chapitre précédent. En effet, ce circuit applique un masque à l'entrée, afin de mettre à 0 les entrées non-sélectionnées. Il fait ensuite un OU entre tous les entrées. LE calcul du masque est réalisé par le décodeur.

On peut aussi simplifier le circuit en remplaçant les portes ET en aval du décodeur par des transistors dont la grille est commandée par le décodeur. Ce faisant, seule une entrée sera connectée à la sortie, alors que les autres seront déconnectées.

==Le démultiplexeur==

Après avoir vu le multiplexeur, il est temps de voir de démultiplexeur. Comme le nom l'indique, le démultiplexeur fait l'exact inverse du multiplexeur. Son rôle est de recopier, sur une des sorties, ce qu'il y a sur l'entrée. Évidemment, la sortie sur laquelle on recopie l'entrée est choisie parmi toutes les sorties possibles. Pour cela, le démultiplexeur possède une entrée de commande, sur laquelle on envoie le numéro de la sortie de destination.

===Le démultiplexeur à deux sorties===

Le démultiplexeur le plus simple est le démultiplexeur à deux sorties. Il possède une entrée de donnée, une entrée de commande et deux sorties, toutes de 1 bit. Suivant la valeur du bit sur l'entrée de commande, il recopie le bit d'entrée, soit sur la première sortie, soit sur la seconde. Les deux sorties sont numérotées respectivement 0 et 1.

[[File:Demultiplexer.png|centre|vignette|upright=1.5|Démultiplexeur à 2 sorties.]]

On peut le concevoir facilement en partant de sa table de vérité.

{|class=&quot;wikitable&quot;
|-
! Entrée de commande ''Select''
! Entrée de donnée ''Input''
!
! Sortie 1
! Sortie 0
|-
| 0 || 0 || || 0 || 0
|-
|-
| 0 || 1 || || 0 || 1
|-
|-
| 1 || 0 || || 0 || 0
|-
|-
| 1 || 1 || || 1 || 0
|-
|}

Le circuit obtenu est le suivant :

[[File:2to4demux.svg|centre|vignette|upright=2|Démultiplexeur à deux sorties.]]

===Les démultiplexeurs à plus de deux sorties===

Il est parfaitement possible de créer des démultiplexeurs en utilisant les méthodes du chapitre sur les circuits combinatoires, comme ma méthode des minterms ou les tableaux de Karnaugh. On obtient alors un démultiplexeur assez simple, composé de deux couches de portes logiques : une couche de portes NON et une couche de portes ET à plusieurs entrées.

[[File:Demux.PNG|centre|vignette|upright=1.5|Démultiplexeur fabriqué avec une table de vérité.]]

Mais cette méthode n'est pas pratique, car elle utilise beaucoup de portes logiques et que les portes logiques avec beaucoup d'entrées sont difficiles à fabriquer. Pour contourner ces problèmes, on peut ruser. Ce qui a été fait pour les multiplexeurs peut aussi s'adapter aux démultiplexeurs : il est possible de créer des démultiplexeurs en assemblant des démultiplexeurs 1 vers 2. Évidemment, le même principe s'applique à des démultiplexeurs plus complexes : il suffit de rajouter des couches.

[[File:Circuit d'un démultiplexeur à 4 sorties, conçu à partir de démultiplexeurs à 2 sorties.jpg|centre|vignette|upright=1.5|Circuit d'un démultiplexeur à 4 sorties, conçu à partir de démultiplexeurs à 2 sorties.]]

Un démultiplexeur peut aussi se fabriquer en utilisant un décodeur et quelques portes ET. Pour comprendre pourquoi, regardons la table de vérité d'un démultiplexeur à quatre sorties. Si vous éliminez le cas où l'entrée de donnée ''Input'' vaut 0, et que vous tenez compte uniquement des entrées de commande, vous retombez sur la table de vérité d'un décodeur. Cela correspond aux cases en rouge.

{|class=&quot;wikitable&quot;
|-
! Input !! E0 !! E1 !! !! S0 !! S1 !! S2 !! S3
|-
| 0 || 0 || 0 || || 0 || 0 || 0 || 0
|-
| 0 || 0 || 1 || || 0 || 0 || 0 || 0
|-
| 0 || 1 || 0 || || 0 || 0 || 0 || 0
|-
| 0 || 1 || 1 || || 0 || 0 || 0 || 0
|-
| 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0
|-
| 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0
|-
| 1 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0 || || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 0
|-
| 1 || bgcolor=&quot;#FF0000&quot; | 1 || bgcolor=&quot;#FF0000&quot; | 1 || || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 0 || bgcolor=&quot;#FF0000&quot; | 1
|}

En réalité, Le fonctionnement d'un démultiplexeur peut se résumer comme suit : soit l'entrée ''Input'' est à 1 et il fonctionne comme un décodeur dont l'entrée est l'entrée de commande, soit l'entrée ''Input'' vaut 0 et sa sortie est mise à 0. On devine donc qu'il faut combiner un décodeur avec le circuit de mise à zéro vu dans le chapitre précédent. On devine rapidement que l'entrée ''Input'' commande la mise à zéro de la sortie, ce qui donne le circuit suivant :

[[File:Démultiplexeur conçu à partir d'un décodeur.jpg|centre|vignette|upright=1.5|Démultiplexeur conçu à partir d'un décodeur.]]

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Les circuits de calcul logique et bit à bit
           | prevText=Les circuits de calcul logique et bit à bit
           | next=Les opérations FFS, FFZ, CTO et CLO
           | nextText=Les opérations FFS, FFZ, CTO et CLO
}}
&lt;/noinclude&gt;</text>
      <sha1>sdyycwndct37qjdg3d2ra7u8uh92nx2</sha1>
    </revision>
  </page>
  <page>
    <title>Les réseaux informatiques/La couche application : le web et ses protocoles</title>
    <ns>0</ns>
    <id>70282</id>
    <revision>
      <id>684256</id>
      <parentid>677754</parentid>
      <timestamp>2022-08-27T18:00:42Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33750" xml:space="preserve">Nous arrivons à la fin de ce cours. Il ne nous reste plus qu'à voir la couche application, celle qui contient la plupart des protocoles liés aux sites web. Et pour bien introduire ce chapitre, commençons par voir quelques notions de base sur les sites web. Rappelons que la majorité des sites web fonctionnent sur le principe du client-serveur, vu dans le premier chapitre sur cours. Un ''site web'' n'est ni plus ni moins qu'un ensemble de fichiers stockés sur un ''serveur web''. Chaque page correspond à un ou plusieurs fichiers : une page en pur texte est d'un seul tenant, alors que les pages avec des vidéos ou des images ont un fichier supplémentaire par image/vidéo. Les ordinateurs qui veulent consulter un site web vont se connecter au serveur : ce sont les ''clients web''. Les ''navigateurs web'' sont des applications qui permettent à un client web de consulter le contenu des serveurs web, pour les consulter pages, télécharger des fichiers, ou toute autre action du même genre.

Au tout début d'internet, les pages web étaient ce qu'on appelle des '''pages web statiques'''. L'ensemble de la page est stocké dans un fichier, qui est interprété tel quel par un navigateur web. Ce fichier n'est cependant pas un fichier image ou un fichier texte habituel, mais est codé dans un langage de description de documents particulier : le HTML, très souvent couplé avec du CSS. Le premier définit une syntaxe particulière pour afficher différents widgets, listes, tableaux texte, et autres. Le second définit diverses options d'apparence, qui permettent de modifier l'allure et les graphismes des widgets. Dans tous les cas, les pages statiques ont un contenu immuable, déterminé lors de leur conception, incapable de s'adapter aux circonstances. Par exemple, elles ne permettent pas de créer des comptes clients, pour se connecter à un site, ou des fioritures similaires.

De nos jours, le HTML et le CSS sont complétés par d'autres langages de programmation, qui permettent d'obtenir des sites plus évolués. Ces sites ont des '''pages web dynamiques''', qui peuvent s'adapter au client. Ces pages web sont calculées à la volée par le serveur, ce qui est utile dans divers scénarios. Par exemple, un site web sur lequel on peut s'inscrire ou avec un forum sera systématiquement une page web dynamique. Le langage de programmation utilisé par sur ces pages est souvent le PHP, éventuellement du Javascript. Le PHP est un langage qui s’exécute sur le serveur, ce qui permet notamment l'accès à une BDD quelconque. La page web est alors construite, calculée à la volée par le serveur. En comparaison, le Javascript est un langage qui s’exécute sur le client, dans son navigateur web. Il faut noter que le HTML et le CSS sont cependant utilisés de concert avec PHP/Javascript sur les pages dynamiques. 

==Les adresses web (URL)==

Toute page web a une adresse appelée '''adresse URL''', qui est utilisée pour y accéder ou pour créer des liens vers celui-ci. Les adresses URL ressemblent plus ou moins à ceci : ''http://www.example.com''.

Prenons une adresse URL, https://www.fr.wikipedia.org/wiki/Wikip%C3%A9dia:Accueil_principal par exemple. Il faut savoir que seule une partie de l'adresse URL est utile pour identifier l'adresse IP du serveur. Le reste de l'adresse sert à indiquer quel est le fichier demandé, mais ne sert pas à spécifier le serveur. La partie de l'URL qui détermine l'IP est ce qu'on appelle le '''nom de domaine'''. Généralement, le nom de domaine est situé après www. et avant le symbole &quot;/&quot; qui suit. En reprenant l'adresse suivante, le nom de domaine est www.fr.wikipedia.org et le reste de l'adresse, /wiki/Wikip%C3%A9dia:Accueil_principal, sert à indiquer où on doit aller chercher le fichier.

[[File:URL example.svg|centre|vignette|upright=2.0|URL example]]

===L'organisation hiérarchique des domaines===

Un nom de domaine est composé de plusieurs noms, séparés par des points. Chaque nom fait référence à ce qu'on appelle un '''domaine internet''', quelque chose qui regroupe plusieurs sites ou pages web qui ont un lien.

L'ensemble des domaines est organisée de manière hiérarchique, avec des domaines de 1er niveau, de 2nd niveau, de 3ème niveau, etc.

[[File:CPT-internet-domainnames.svg|centre|vignette|upright=2.0|Organisation hiérarchique des domaines internet.]]

Les domaines principaux, appelés '''domaines de premier niveau''', sont les fameux domaines .fr, .uk, .com, .org, et ainsi de suite. Ils sont gérés par l'ICANN (Internet Corporation for Assigned Names and Numbers), un organisme américain, depuis 1998. L'ICANN distingue deux types de noms de domaines : les domaines géographiques (.fr, par exemple) sont liés à un pays, tandis que les autres sont liés à des organisations (.gov pour les gouvernements, .edu pour les établissements scolaires, .mil pour les organismes militaires, et quelques autres). 

En dessous de ces domaines, on trouve des '''domaines de second et de troisième niveau''', qui sont subordonnées aux domaines de niveau inférieur. Par exemple, le .gouv est un domaine de second niveau (un sous-domaine) : tous les sites en .gouv seront des sites en .fr. Ces sous-domaines sont des sortes de subdivisions d'un domaine de premier niveau. Même chose pour les domaines de troisième niveau, qui sont des subdivisions d'un domaine de second niveau.

Enfin, les domaines de plus bas niveau regroupent les pages web d'un même site. En effet, dans le cas général, toutes les pages d'un site web font partie du même domaine. Par exemple, dans le nom de domaine ''www.fr.wikipedia.org'', c'est le cas du domaine ''wikipedia''.

Chaque domaine de second niveau appartient à un domaine de 1er niveau, de même que les domaines de 3ème niveau appartiennent à un domaine de 2nd niveau et ainsi de suite. On peut relier les domaines en fonction de leurs relations d'inclusion, ce qui donne un arbre qui organise les domaines de manière hiérarchique. Cet arbre est ce qu'on appelle la '''hiérarchie des noms de domaine'''. Une partie de cet arbre est illustrée ci-dessous.

[[File:DNS Tree.svg|centre|vignette|upright=2.0|Hiérarchie des noms de domaine.]]

===Les domaines les plus courants===

[[File:Domenywikiversion.gif|vignette|Liste de quelques domaines géographiques européens.]]

Les noms de domaines peuvent être lié à la localisation géographique ou la langue du site : c'est par exemple le cas du domaine .fr ou .uk. De tels domaines sont appelés des '''domaines géographiques'''. La plupart de ces domaines sont liés à des pays, comme le .fr pour la France, l’Angleterre pour le .uk, l’Espagne pour le .es, etc. Ce sont des domaines dits nationaux. En tout, il existe près de 206 noms de domaines nationaux. Il existe aussi quelques pays liés à des régions à l'intérieur d'un pays, voire à des villes, comme le .paris ou le .alsace en France. Les domaines liés à des pays sont tous des domaines de 1er niveau, alors que ceux des régions/villes sont des domaines de 2nd niveau. 

D'autres domaines ne sont pas liés à un pays, mais ont une utilisation plus large. En voici quelques-uns :

* Le ''.com'' a été conçu pour être le nom de domaine pour les sites commerciaux. D'ailleurs, ''.com'' est l'abréviation de ''.commercial''. Mais son rôle a changé depuis et il est depuis ouvert à tous. Il regroupe donc des sites très différents, sans règles particulières.
* Le ''.org'' a été conçu pour être utilisé pour les organisations privées à but non-commercial. Comme pour le ''.com'', il est depuis ouvert à tous les sites qui en font la demande. À ce propos, les sites de la wikifondation (wikipédia, wikilivres, wikicommons), sont dans le domaine''.org''.
* Le ''.gov'' est utilisé pour les organismes gouvernementaux américains. Les autres pays ont bien un domaine pour leurs organismes gouvernementaux, mais il s'agit d'un domaine de second niveau. Par exemple, en France, le domaine pour les organismes gouvernementaux est le ''.gouv'', qui est un sous-domaine du ''.fr''.
* Le ''.edu'' est utilisé pour les organismes d'enseignement de grande ampleur, comme les universités ou les grandes écoles. Il est surtout utilisé par les organismes américains, mais quelques organismes non-américains ont un domaine en ''.edu''.
* Et il y en a bien d'autres, comme le ''.info'', le ''.net'', le ''.arpa'', le ''.int'', le ''.mail'', etc.

==La conversion des noms de domaine en adresses IP==

Comme dit plus haut, un nom de domaine identifie un ordinateur/serveur bien précis sur le net. Mais l'accès à un fichier sur ce dit serveur doit se faire par des communications basées sur le réseau IP, les noms de domaine ne pouvant pas servir directement pour communiquer. Pour lire une page web, le navigateur web doit découvrir l'adresse IP du serveur, à partir de son nom de domaine. Cette traduction d'un nom de domaine en IP peut se faire de plusieurs manières différentes : soit avec un fichier pré-configuré, soit avec un protocole dédié (le protocole DNS).

Notons que distinguer les adresses IP et les noms de domaine est plus simple pour les être humains (une suite de mots est plus facile à retenir qu'une suite de nombres), mais a aussi d'autres avantages. Par exemple, cela permet de changer plus facilement un serveur pour un autre, tout en gardant le même nom de domaine. Pour en donner un exemple, cela permet d'utiliser un serveur de sauvegarde en complément du serveur principal. Si le serveur principal tombe en panne, la mise à jour des correspondances ''ip &lt;-&gt; nom de domaine'' suffit pour faire le remplacement.

===Le fichier HOST===

Au tout début d'internet, les correspondances entre IP et URL étaient mémorisées dans des fichiers HOSTS.TXT, qui existe toujours sur certains systèmes d'exploitation.

[[File:Host txt-file.jpg|centre|vignette|upright=2.0|Exemple d'entrée dans le fichier Host.txt.]]

Ce fichier était accessible sur un serveur dédié, maintenu par le Network Information Center. Mais cette méthode a rapidement montré ses limites avec l'augmentation du nombre de sites. Vu le nombre actuel de sites web, on ne peut pas en garder un gros annuaire dans un seul et unique fichier sur chaque ordinateur.

Cependant, le fichier host.txt est toujours utilisé par les systèmes d'exploitation modernes et les navigateurs web peuvent l'utiliser comme bon leur semble. Modifier le fichier host.txt permet de bloquer des sites web : il suffit de leur attribuer une adresse IP invalide. Cette technique est une des techniques utilisée par certains logiciels de contrôle parental. Elle est aussi utilisée par des antispywares comme Spybot : celui-ci bloque des sites web conçus pour propager des spywares, en les bloquant via le fichier Host.txt.

===Le protocole DNS===

De nos jours, le navigateur ne connait pas l'IP qui correspond à l'URL, et il doit la récupérer sur le net. Des serveurs naissent et meurent tous les jours, et l'IP associée à une URL peut ainsi changer. Pour récupérer cette IP, le navigateur va devoir utiliser un protocole (oui, encore un) : le '''protocole Domain Name System''' (DNS). Ce protocole mémorise les correspondances IP - URL sur plusieurs serveurs DNS. L'ensemble de ces serveurs DNS contient en quelque sorte l'annuaire d'internet. Le protocole DNS est utilisé avant toute communication avec un serveur web. D'abord, le navigateur web communique avec des serveurs DNS pour récupérer l'IP du serveur, et ensuite il utilise cette IP pour télécharger la page web demandée. Le protocole DNS indique comment on doit interroger les serveurs DNS et comment ceux-ci doivent répondre aux demandes qui leur sont envoyées. C'est un simple standard de communication, du moins pour simplifier.

[[File:Dns-server-upload.png|centre|vignette|upright=2.0|Aperçu de l'interaction entre DNS et autres protocoles. Le navigateur communique d'abord avec les serveurs DNS pour récupérer l'IP du serveur voulu, et il s'y connecte ensuite.]]

====Les serveurs racine====

Si les noms de domaines sont structurés de manière hiérarchique, il est évident que cette organisation se retrouve pour la traduction en adresses IP. Quand un navigateur veut traduire un nom de domaine en IP, il va interroger un '''serveur racine'''. Au début d'Internet, les serveurs principaux étaient au nombre strict de 13 et étaient nommés serveurs A, B, C, D, E, F, G, H, I, J, K, L, et M. De nos jours, les serveurs racine principaux sont complétés par des serveurs relais, ainsi que par des serveurs de rechange, qui s'activent quand un serveur tombe en panne ou est surchargé.

[[File:Root-historic.svg|vignette|upright=2.0|Serveurs DNS racine historiques.]]
[[File:Root-current.svg|vignette|upright=2.0|Serveurs DNS racine actuels.]]

[[File:Main root DNS servers.JPG|centre|vignette|upright=2.0|Liste des 13 serveurs racines principaux.]]

====Le parcours récursif de la hiérarchie des domaines====

Prenons un client DNS qui veut consulter le site fr.wikipedia.org, mais qui ne connait pas l'IP qui correspond. Le navigateur connait les adresses IP des serveurs racine, qui sont des adresses fixes et réservées. Il peut donc interroger le serveur racine et lui demander quel est l'IP du site. Il lui envoie une requête DNS, qui transmet le nom de domaine et auquel le serveur doit répondre. Le serveur DNS peut répondre de deux manières : soit le serveur connait l'IP qui correspond au nom de domaine, soit il peut donner l'IP d'un serveur qui devrait connaitre cette adresse. Dans le premier cas, l'IP est renvoyée par le serveur et la recherche s’arrête. Dans le second cas, le serveur racine renvoyer l'IP d'un autre serveur DNS, qui peut correspondre au nom de domaine associé. Le processus de recherche continue tant qu'on lui fournit une adresse de serveur DNS qui peut contenir l'IP voulue.

Dans le détail, tout commence par une question envoyée au serveur racine. Le serveur racine ne connait pas l'IP du site web demandé, quel qu’il soit. Par contre, il sait quels sont les serveurs associés à chaque domaine de premier niveau, et peut renvoyer leur adresse IP. Le client reçoit la réponse et renvoie sa requête à l'IP envoyée, au serveur de premier niveau. Le serveur DNS de premier niveau renvoie alors l'adresse d'un serveur chargé du domaine de second niveau. Et ainsi de suite : le processus se poursuit jusqu'à ce qu'on tombe sur l'IP recherchée.

[[File:DNS iterations.svg|centre|vignette|upright=2.0|Example of an iterative DNS resolver]]

La plupart des nœuds réseaux mémorise les réponses aux demandes les plus courantes dans une portion de RAM : le '''cache DNS'''. Par exemple, tout ordinateur dispose d'un cache DNS dans sa mémoire, qui permet de mémoriser les IP des sites récemment visités. Quand un site est visité la première fois, on conserve son IP, afin de la réutiliser lors des prochains accès. Pas besoin de demander l'IP du site à chaque fois, seul le premier accès entraine une requête DNS. Ainsi, les réponses aux requêtes les plus fréquentes peuvent être lues depuis ce cache, ce qui est plus rapide. Cependant, les résultats sont effacés du cache après un certain temps, au cas où l'IP associée à un nom de domaine change.

[[File:DNS in the real world.svg|centre|vignette|upright=2.0|Intégration du DNS dans les navigateurs web et les FAI.]]

====Les requêtes et réponses DNS====

Les requêtes envoyées aux serveurs DNS ont le même format que les réponses de ces serveurs. Le paquet DNS est composé d'un en-tête suivi par une ou plusieurs requêtes/réponses de taille fixe.

* L'''en-tête DNS'' est structuré comme suit :
** Il commence par un champ d'identification qui contient le numéro à la transaction DNS. Ce numéro permet de savoir quelle réponse est associée à quelle requête : par exemple, la réponse numéro 15 contient les IP demandées par la requête numéro 15.
** Il est suivi par quelques ''flags'', des bits qui précisent quelques options déterminées.
** Le reste donne le nombre de requêtes et de réponses DNS dans le paquet DNS. Le nombre de requêtes est variable dans le paquet, et il n'est pas rare qu'il y en ait plusieurs dans le même paquet, mais elles sont toutes placées les unes à la suite des autres. Il en est de même avec le nombre de réponses : le serveur peut rassembler plusieurs réponses dans un seul paquet.
* L'en-tête est suivi par les requêtes et les réponses DNS, qui forment le ''contenu du paquet DNS''.
** Chaque requête contient l'adresse URL à traduire, ainsi que quelques informations annexes.
** Les requêtes sont ensuite suivies par les réponses de la part du serveur.
** D'autres informations additionnelles sont placées à la fin du paquet.

[[File:Dns message.jpg|centre|vignette|upright=3.0|Message DNS, valable autant pour les réponses que pour les requêtes.]]

: ''Pour ceux qui veulent en savoir plus, je conseille la lecture du wikilivre sur le DNS, disponible à cette adresse :''

* [[Système de noms de domaine]]

==Le protocole HTTP==

Une fois que le DNS a permis d'obtenir l'IP du serveur web, il est temps d'échanger des informations avec le serveur. Pour les communications entre serveur et client web, il existe un protocole dédié : l''''HyperText Transfert Protocol''', aussi appelé HTTP. Le HTTP est pris en charge par les navigateurs web et par les serveurs web. Les navigateurs web sont installés sur l'ordinateur client, les serveurs étant installés...sur les serveurs. Les échanges client-serveur se basent sur le protocole TCP : on dit que HTTP est basé sur le TCP. Il a existé plusieurs versions du protocole HTTP, la toute première étant la version 0.9 et la dernière la 1.1 (à l'heure où j'écris ces lignes, janvier 2016). Il peut paraitre bizarre que la première version soit la 0.9 et non la 1.0. Mais il faut savoir que la 0.9 n'avait pas de numéro de version à la base, l'introduction des numéros de version s'étant fait en catastrophe à partir de la version 1.0. L'ancienne version sans numéro a alors été renommée en HTTP 0.9.

Le '''HTTPS''' est une version chiffrée du HTTP, où les commandes sont transmises après avoir étés cryptées. Cette version du HTTP existe pour une raison simple : avec le HTTP normal, un attaquant peut parfaitement intercepter les paquets et avoir accès à leur contenu. Et si ce contenu est votre code de carte bleu, que vous avez saisi pour faire des achats en ligne, cela peut donner une belle catastrophe. Pour éviter cela, le HTTP utilise un système de chiffrement dit asymétrique, qui empêche toute attaque de ce genre. Ce système de chiffrement est basé sur le protocole '''Transport Layer Security''' aussi appelé TLS.

===Les connexions HTTP===

[[File:HTTP Connections.svg|vignette|Connexions HTTP.]]

Comme on l'a dit plus haut, HTTP est un protocole en mode connecté : le client doit se connecter au serveur avant de pouvoir lui envoyer des commandes HTTP. C’est pour cette raison qu'HTTP est basé sur le protocole TCP, qui a un mode connecté, et non sur UDP, protocole sans connexion. Il arrive que le client et le serveur doivent faire plusieurs échanges successifs et communiquer sur une période de temps assez longue. On se retrouve alors avec un choix à faire : est-ce que chaque échange ouvre et ferme une connexion dédiée, ou est-ce que ces échanges sont pris en charge par une seule connexion ?

Dans le premier cas, chaque échange a sa propre connexion. Tout envoi de commande HTTP ouvre une connexion, qui sera fermée lors de la réponse du serveur. C'est ce qu'on appelle des '''connexions non-persistantes'''.

Dans le second cas, le client ouvre une connexion avec le serveur, effectue autant d'échanges qu'il souhaite avec cette connexion et ne la ferme qu'une fois l'ensemble des échanges terminés. C'est ce qu'on appelle des '''connexions persistantes'''. Avec elles, les connexions TCP ne sont pas fermées après que le serveur a répondu à une commande : elles peuvent servir pour plusieurs commandes successives. Cela permet d'économiser des connexions TCP, chose qui améliore quelque peu les performances. Les termes persistants et non-persistants caractérisent bien la nature de ces connexions. Avec les versions 0.9 et 1.0 du HTTP, les connexions sont non-persistantes. Les versions suivantes du HTTP utilisent les connexions persistantes.

[[File:HTTP persistent connection.svg|centre|vignette|upright=2.0|Connexions persistantes HTTP.]]

Une autre optimisation permise par le HTTP 1.1 est le '''pipelining HTTP'''. Avec cette technique, un client HTTP peut envoyer une nouvelle commande, sans attendre que le serveur réponde à la précédente. Au lieu d'envoyer les commandes unes par unes, on peut les envoyer en rafales.

[[File:HTTP pipelining.svg|centre|vignette|upright=2.0|Pipelining HTTP.]]

===Les commandes HTTP===

Chaque échange du client vers le serveur, ou inversement, prend la forme d'un '''message HTTP'''. Les messages envoyés du client vers le serveur sont des '''requêtes HTTP''', alors que ceux allant dans l'autre sens sont des '''réponses HTTP'''. Ces messages HTTP sont de simples fichiers texte encodés en ASCII, lisibles par tout être humain avec un cerveau en état de marche.

====Les requêtes HTTP====

Le protocole HTTP normalise différentes requêtes HTTP, comme GET, HEAD ou POST, qui agissent chacune sur une URL. Ces commandes sont envoyées dans des paquets TCP, le contenu de la commande étant placé dans les données du paquet. Ces commandes sont envoyées par le client, et le serveur doit obligatoirement répondre à celles-ci : ces commandes sont des ordres envoyés au serveur.

Ces commandes sont les suivantes :

* GET : obtenir la page web demandée ; 
* HEAD : obtenir des informations sur la page, sans la consulter ; 
* POST : envoyer une ressource sur le serveur (un message sur un forum, par exemple) ; 
* PUT : remplace ou ajoute une ressource sur le serveur ; 
* DELETE : supprime une ressource sur le serveur ; 
* OPTIONS : obtenir les options de communications utilisées par le serveur ; 
* CONNECT : commande spécialisée pour les proxys ; 
* TRACE : permet de tester la liaison entre serveur et client.

Le message HTTP envoyé au serveur est un fichier texte formaté d'une certaine manière. Voici un exemple de requête HTTP :

    GET /somedir/page.html HTTP/1.1
    Host: www.someschool.edu
    Connection: close
    User-agent: Mozilla/5.0
    Accept-language: fr

On voit que la première ligne donne toutes les informations pour traiter la requête. Elle est appelée la '''ligne de requête'''. Elle commence par le nom de la commande, suivi de l'adresse URL demandée, elle-même suivie par la version de HTTP utilisée. La ligne de requête est suivie par une ou plusieurs '''ligne d'en-tête''', qui fournissent des informations diverses. La ligne ''Host'' donne le nom de domaine qui doit répondre à la requête. La ligne ''Connection'' précise s'il faut utiliser des connexions persistantes ou non : close signifie que les connexions ne doivent pas être persistantes, alors que open les autorise. La ligne User-agent donne des informations sur le navigateur web à l'origine de la requête. La ligne ''Accept-language'' précise la langue préférée pour la réponse.

====Les réponses HTTP====

Le serveur répond à ces commandes en envoyant un paquet au contenu standardisé. Celui-ci peut contenir la page web demandée, pour répondre aux commandes GET ou HEAD, par exemple. Mais dans tous les cas, le serveur web indique si tout s'est bien passé ou si une erreur a eu lieu. Pour cela, il renvoie un '''code de statut HTTP''', qui indique si tout s'est bien passé et quelles sont les erreurs qui ont eu lieu1. Par exemple, il va renvoyer une 404 si la ressource demandée n'a pas été trouvée sur le serveur. Les plus courants sont :

* 200 : tout s'est bien passé ; 
* 301 et 302 : redirection vers une autre page ; 
* 403 : accès refusé ; 
* 404 : page non trouvée ; 
* 500 : erreur interne au serveur.

Le format des messages de réponse est assez simple à comprendre. Comme pour les requêtes, on trouve une ligne de requête, suivie d'une ligne d'en-tête, et de la page demandée. La première ligne indique la version de HTTP utilisée, suivie du code de statut et d'une phrase. Les lignes d'en-tête fournissent d'autres informations, comme le statut des connexions, la date d'envoi, le type de serveur, etc.

    HTTP/1.1 200 OK
    Connection: close
    Date: Tue, 09 Aug 2011 15:44:04 GMT
    Server: Apache/2.2.3 (CentOS)
    Last-Modified: Tue, 09 Aug 2011 15:11:03 GMT
    Content-Length: 6821
    Content-Type: text/html
    Données de la page

===Les cookies HTTP===

HTTP est ce qu'on appelle un '''protocole sans état''', à savoir que le serveur ne mémorise aucune information sur le client. En conséquence, quand le serveur reçoit une requête, il la traite toujours de la même manière. Un client peut ainsi envoyer plusieurs fois de suite la même requête et recevoir la même réponse : le serveur ne va refuser les requêtes suivantes sous prétexte qu'elles ont déjà été servies. Cette particularité permet de fortement simplifier le protocole, sans compter qu'elle permet un gain de performance non-négligeable par rapport à un protocole avec état. Le traitement d'une requête ne demande pas l'accès à une liste d'informations client ou à un historique de connexions, n'a pas besoin de gaspiller de la RAM pour stocker des informations client, etc. C'est pour cela qu'il existe de nos jours des serveurs capables de traiter plusieurs millions, voire milliards, de connexions simultanées.

Cependant, certaines applications ont besoin de stocker des informations spécifiques à chaque client. Pour cela, HTTP déporte le stockage de ces informations sur le client, au lieu de le mettre sur le serveur. Dans le détail, HTTP permet le stockage sur le client de fichiers utiles pour le serveur, qui sont nommés '''cookies'''. Ceux-ci sont des fichiers que le serveur envoie au client et que ce dernier conserve dans sa mémoire. Dit autrement, les cookies sont des fichiers enregistrés sur votre ordinateur, par les sites web. Leur utilité est de mémoriser des informations sur votre ordinateur, et non sur le serveur lui-même. Ils peuvent contenir absolument tout et n’importe quoi, tant que le site aura jugé utile d'enregistrer ces informations dans le cookie. Par exemple, ils peuvent y enregistrer vos MDP et login, ce qui vous permet de ne pas avoir à les saisir à chaque connexion, de vous maintenir connecté. Les sites d'e-commerce sauvegardent aussi les paniers de produits réservés/sélectionnés avant qu'on passe commande. Ce sont des fichiers texte, et ne sont donc pas des programmes exécutables (ce ne sont donc pas des virus). 

[[File:HTTP cookie exchange.svg|vignette|upright=1.5|Échange de cookies HTTP entre client et serveur.]]

À chaque fois que vous envoyez une requête à un serveur, celui-ci lira les cookies qu'il a déposés sur votre ordinateur et peut les mettre à jour. La seule exception est pour la première requête, vu que le serveur n'a pas pût déposer de cookie sur le client. Pour résumer, tout se déroule comme suit : le client envoie une première requête au serveur, puis le serveur renvoie le fichier demandé (une page web, par exemple), ainsi que le cookie. On dit que le serveur dépose le cookie sur votre ordinateur. Les requêtes suivantes renvoient le cookie en plus de la requête proprement dite. 

Les cookies peuvent être conservés dans la mémoire RAM ou sur le disque dur, ce qui permet de distinguer deux types de cookies : les temporaires et les persistants. Les '''cookies temporaires''' (aussi appelés cookies de session) sont maintenus dans la mémoire RAM de l'ordinateur et ne sont pas sauvegardés sur le disque dur. Lors de la fermeture du navigateur, ils sont effacés ou perdus. Ce n'est pas le cas des '''cookies persistants''', qui sont sauvegardés sur le disque dur et ne s'effacent pas quand on ferme le navigateur. Le seul moyen de les supprimer est d'utiliser les options du navigateur, qui contiennent systématiquement de quoi les effacer. On peut aussi utiliser des utilitaires de nettoyage de disque, mais c'est quelque chose de déconseillé, pour diverses raisons.

: Il est demandé aux navigateurs de supporter ''a minima'' :

* 300 cookies simultanés ; 
* 4096 octets par cookie ; 
* 20 cookies par « serveur » (hôte/domaine).

====Les cookies traceurs====

L'utilisation des cookies n'est pas forcément bienveillante, ni dans l'intérêt de l'utilisateur. Par exemple, certains services de publicité en ligne suivent les internautes sur plusieurs sites et collectent des informations grâce à un cookie de traçage enregistré sur l'ordinateur. Ces cookies permettent de tracer un utilisateur sur plusieurs sites qui partagent des éléments communs. Il suffit qu'une bannière publicitaire ou tout autre forme de publicité soit utilisée sur plusieurs sites. La visite du premier site dépose un cookie, que les autres sites consultés peuvent consulter. Le serveur de publicité sait, grâce à l'analyse du cookie de traçage, quels sont les sites visités par l'utilisateur.

Quelques extensions de navigateur web permettent de supprimer ou de bloquer ces cookies traceurs. On pourrait notamment citer les extensions Privacy Badger ou Ghostery, pour Firefox et Chrome. Les navigateurs internet récents ont commencé à prendre le problème au sérieux, en ajoutant une option qui empêche les sites de vous suivre à la trace avec de tels cookies. Cette option, appelée Do Not Track (ne me suivez pas), a cependant été mal implémentée : via cette option, on peut indiquer aux sites que l'on ne souhaite pas être pisté, mais ceux-ci font ce qu'ils veulent de cette information et peuvent parfaitement décider de la passer outre. En effet, il n'y a pas de contraintes légales quant à l'utilisation de cette option. De plus, cette option doit être activée dans les options du navigateur : elle est désactivée par défaut.

==Le protocole FTP (''File Transfert Protocol'')==

Le '''protocole FTP''' (''File Transfert Protocol'') est un protocole qui permet à un client de gérer les fichiers sur un serveur. Le protocole FTP permet au client de télécharger des fichiers sur un client (l'utilisation principale de FTP), mais aussi de modifier, remplacer ou supprimer des fichiers sur le serveur. FTP est un protocole de type client-serveur, dans le sens où il faut intervenir deux programmes : un logiciel sur le serveur, appelé serveur FTP, ainsi qu'un logiciel sur le client qui est appelé un client FTP. À l'instar d'HTTP, il existe des versions sécurisées de FTP, qui utilisent des systèmes de cryptage comme le SSL ou le TLS, qui sont appelées le FTPS.

===Les connexions FTP : commande et données===

La communication entre les deux utilise des connexions TCP, deux en tout :
* Une connexion pour le transfert des données entre client et serveur, qui peut fonctionner pour transférer des fichiers dans les deux sens (du client vers le serveur, ou inversement).
* Une connexion de commande, par laquelle le client envoie des ordres au serveur (requête de téléchargement, de suppression ou de modification de fichier, autre).

[[File:FTP mode actif.svg|centre|vignette|upright=2.0|Connexions du protocole FTP (en mode actif).]]

[[File:Passive FTP Verbindung.svg|vignette|Établissement d'une connexion FTP.]]

L'établissement des deux connexions se fait en deux étapes. Le processus est illustré ci-contre.
* En premier lieu, le client envoie une '''commande FTP''' au serveur FTP. Elle prend la forme d'un paquet FTP spécial, nommé PASV ou ACTV selon le mode de connexion.
* Le serveur envoie alors une réponse au client FTP, qui dit si la connexion est acceptée et sur quelle port. Elle prend la forme d'un message composé : d'un '''code réponse''' de trois chiffres codés en ASCII, parfois suivie d'un message texte optionnel. Par exemple, la réponse 200 OK signifie que la connexion est acceptée.
* À la suite de cette réponse, la connexion est établie.

: La liste des ''codes réponses'' des serveurs FTP et des ''commandes FTP'' est disponible via ce lien wikipédia : 
: * [https://en.wikipedia.org/wiki/List_of_FTP_commands List of FTP commands.]
: * [https://en.wikipedia.org/wiki/List_of_FTP_server_return_codes List of FTP server return code.]

===Le mode actif et le mode passif===

Les deux connexions utilisent des ports distincts au niveau du serveur : le port 21 pour la réception des commandes et le port 20 pour le transfert des données. Cependant, il arrive que le port de transfert des données soit différent. Il faut dire qu'il peut faire l'objet d'une négociation entre client et serveur. Cela permet de distinguer deux types d'usage du FTP : le mode actif et le mode passif. Dans le mode actif, c'est le client FTP qui décide du port à utiliser pour le transfert de données. En mode passif, c'est le serveur qui décide sur quel port il émet les données. Le mode passif est surtout utilisé quand le client est protégé par un pare-feu, car il est le seul mode possible, le mode actif posant quelques problèmes avec les pare-feu.

{|
|[[File:FTP mode actif.png|vignette|upright=1.5|FTP mode actif]]
|[[File:FTP mode passif.png|vignette|upright=1.5|FTP mode passif]]
|}

&lt;noinclude&gt;
{{NavChapitre | book=Les réseaux informatiques
           | prev=La couche présentation
           | prevText=La couche présentation
}}{{autocat}}
&lt;/noinclude&gt;</text>
      <sha1>85gukec729k6brqwccmcfxijb6svp7t</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Fabricants/Trizio</title>
    <ns>0</ns>
    <id>71460</id>
    <revision>
      <id>684316</id>
      <parentid>596164</parentid>
      <timestamp>2022-08-27T18:52:58Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="628" xml:space="preserve">{{Ph s Fabricants}}


== Photos à classer ==
&lt;gallery&gt;
Set di filtri fotografici giallo, magenta, ciano - Museo scienza tecnologia Milano 15510.jpg|Valise avec jeux de filtres jaune, magenta, cyan (1900 - 1949)
Set di filtri fotografici giallo, magenta, ciano - Museo scienza tecnologia Milano 15510 01.jpg
Set di filtri fotografici giallo, magenta, ciano - Museo scienza tecnologia Milano 15510 02.jpg
Set di filtri fotografici giallo, magenta, ciano - Museo scienza tecnologia Milano 15510 03.jpg
Set di filtri fotografici giallo, magenta, ciano - Museo scienza tecnologia Milano 15510 04.jpg
&lt;/gallery&gt;


{{Ph Fabricants}}</text>
      <sha1>mhy2hutedlcw6161fbar8mshxdnankd</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Fabricants/Simco</title>
    <ns>0</ns>
    <id>71500</id>
    <revision>
      <id>684302</id>
      <parentid>596175</parentid>
      <timestamp>2022-08-27T18:35:08Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="373" xml:space="preserve">{{Ph s Fabricants}}


== Photos à classer ==
&lt;gallery&gt;
Pulitore elettrostatico per lastre fotografiche - Museo scienza tecnologia Milano 09625 01.jpg
Pulitore elettrostatico per lastre fotografiche - Museo scienza tecnologia Milano 09625 02.jpg
Pulitore elettrostatico per lastre fotografiche - Museo scienza tecnologia Milano 09625 03.jpg
&lt;/gallery&gt;


{{Ph Fabricants}}</text>
      <sha1>g68vg9r3s6xpa206hf9pb1j141s939w</sha1>
    </revision>
  </page>
  <page>
    <title>Photographie/Personnalités/K/Ronald Kroon</title>
    <ns>0</ns>
    <id>71866</id>
    <revision>
      <id>684252</id>
      <parentid>599996</parentid>
      <timestamp>2022-08-27T15:33:48Z</timestamp>
      <contributor>
        <username>Richardkiwi</username>
        <id>63342</id>
      </contributor>
      <minor />
      <comment>([[c:GR|GR]]) [[c:COM:FR|File renamed]]: [[File:100 Mijls race op IJsselmeer HKH Prinses Beatrix en Zijne Koninklijke Hoogheid , Bestanddeelnr 254-8152.jpg]] → [[File:100 Mijls race op IJsselmeer HKH Prinses Beatrix en ZKH Bernhard op de Groene Draeck, Bestanddeelnr 254-8152.jpg]] Criterion 3 (missing words/names)</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2872" xml:space="preserve">{{Ph s Personnalités}}


[[Image:Portret van de zwemmer Ron Kroon, Bestanddeelnr 921-6731.jpg|thumb|240px|Ron Kroon]]
== Biographie ==

'''Ronald (&quot;Ron&quot;) Kroon''' était un nageur néerlandais qui gagna deux médailles de bronze lors des championnats d'Europe de 1962. Il concourut également aux Jeux Olympiques de 1960 et 1964, terminant à la 8e place du relais 4 fois 100 m 4 nages. De 1960 à 1964 il fut 4 fois champion des pays-Bas et battit 12 fois le record national du 100 m nage libre, devenant le premier Néerlandais à nager le 100 m en moins de 55 s.

Après sa carrière de nageur, Kroon devint photographe pour l'[[agence ANEFO]] (1965 - 1968) et journaliste (AVRO).
{{clr}}
== Publications ==

== Galerie de photographies ==
&lt;gallery widths=&quot;240px&quot; heights=&quot;240px&quot;&gt;
François truffaut.jpg|François Truffaut
100 Mijls race op IJsselmeer HKH Prinses Beatrix en ZKH Bernhard op de Groene Draeck, Bestanddeelnr 254-8152.jpg
100 Mijls race, Hare Koninklijke Hoogheid Pr. Beatrix en Zijne Koninklijke Hoogh, Bestanddeelnr 254-8259.jpg
100 Mijls race, Hare Koninklijke Hoogheid Pr. Beatrix en Zijne Koninklijke Hoogh, Bestanddeelnr 254-8260.jpg
100-jarig bestaan Rode Kruis . Professor L. J. R. Beel koopt eerst zegels van A., Bestanddeelnr 920-5798.jpg
100-jarig bestaan Rode Kruis . Professor L. J. R. Beel koopt eerst zegels van A., Bestanddeelnr 920-5799.jpg
Barbara (1965).jpg
Britton Chance (1965).jpg
Ed van Thijn (4 november 1965).jpg
Enno Endt (1965).jpg
Frits Diepen (1965).jpg
Gerd Wiltfang (1965).jpg
Guus Oster (1965).jpg
Helga Niessen-Masthoff (1965).jpg
Helga Niessen-Masthoff 1965.jpg
Hudson John (1965).jpg
Jan van Gorp (1965).jpg
Man and woman, by Líbero Badíi.jpg
Mary Soames (1965).jpg
New York City Ballet in Amsterdam, repetitie New York City Ballet. Choreograaf George Balanchine geeft aanwijzingen.jpg
Nina Simone (1965).jpg
Patricia Neary en Conrad Ludlow (1965).jpg
Suzanne Farrell (1965).jpg
Willem H Brummelkamp (1965).jpg
Ivo Samkalden in gesprek met Willem Drees.jpg
Aart Snoek (1966).jpg
Ada Kok (1966-08-23).jpg
Al Hirt (1966).jpg
ALM Schröder (1966).jpg
Bobby Charlton (1966).jpg
Boudewijn de Groot en Ann Burton.jpg
Cees van Dongen (1966).jpg
Cliff Drysdale (1966).jpg
Cor Kieboom (1966).jpg
Dave Berry (1966).jpg
Elmar Klos (1966).jpg
Freddie Lennon (1966).jpg
Gigliola Cinquetti (1966).jpg
Gretta Kok (1966).jpg
Hana Brejchová (1966).jpg
Hans van Mierlo (1966).jpg
Jnan Hansdev Adhin (1966).jpg
Joan Baez (1966).jpg
Joan Baez 1966.jpg
Joop Tinkhof (1966).jpg
Josina Soumokil-Taniwel (1966).jpg
Judith Bosch (1966).jpg
Juliette Gréco (29-03-1966).jpg
&lt;/gallery&gt;

{{T|[[Commons:Category:Photographs by Ron Kroon|voir d'autres photographies de Ron Kroon sur Wikimedia Commons (plus de 8 000)]]}}

== Bibliographie ==


{{Ph Personnalités}}

{{DEFAULTSORT:Kroon, Ronald}}

[[Catégorie:Personnalités de la photographie]]</text>
      <sha1>lvbmv03paks897qu0hl1wo43fmtcdtl</sha1>
    </revision>
  </page>
  <page>
    <title>Biophilosophie/Livres</title>
    <ns>0</ns>
    <id>74946</id>
    <revision>
      <id>684258</id>
      <parentid>640472</parentid>
      <timestamp>2022-08-27T18:01:31Z</timestamp>
      <contributor>
        <username>DavidL</username>
        <id>1746</id>
      </contributor>
      <comment>[[Spécial:LintErrors/missing-end-tag]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="530" xml:space="preserve">= Livres en langue française =
*{{w|Le Normal et le pathologique}}, {{w|Georges Canguilhem}}, (1943, 1966)
*{{w|La Connaissance de la vie}}, {{w|Georges Canguilhem}}, (1952, 1965)
*{{w|La Logique du vivant, une histoire de l’hérédité}}, {{w|François Jacob}}, 1970.
*''L'évolution sans projet'' dans ''Le Darwinisme aujourd'hui'', {{w|François Jacob}}, 1979. 
*Le Jeu des possibles, essai sur la diversité du vivant, {{w|François Jacob}}, 1981.
*{{w|Le Hasard et la Nécessité}}, {{w|Jacques Monod}}, 1970.

{{AutoCat}}</text>
      <sha1>fqbyfrhy3atwvdcof76honmt1zr2t3y</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation GTK2 en Pascal/Version imprimable</title>
    <ns>0</ns>
    <id>78949</id>
    <revision>
      <id>684229</id>
      <timestamp>2022-08-27T12:48:24Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <comment>Page créée avec « {{imprimable}} »</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="14" xml:space="preserve">{{imprimable}}</text>
      <sha1>tqnwxo9j8ualh5dikp6cedpsb1i6zh3</sha1>
    </revision>
  </page>
</mediawiki>