Philosophie/Histoire de la philosophie

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="fr">
  <siteinfo>
    <sitename>Wikilivres</sitename>
    <dbname>frwikibooks</dbname>
    <base>https://fr.wikibooks.org/wiki/Accueil</base>
    <generator>MediaWiki 1.47.0-wmf.9</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="1728" case="first-letter">Event</namespace>
      <namespace key="1729" case="first-letter">Event talk</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Philosophie/Histoire de la philosophie</title>
    <ns>0</ns>
    <id>615</id>
    <revision>
      <id>769254</id>
      <parentid>764752</parentid>
      <timestamp>2026-07-01T03:43:53Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769254</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24307" sha1="kdybjdgufc34masjcpcmiwxzzzfdv3m" xml:space="preserve">&lt;!-- ═══════════════════════════════════════════════════════════════════
     SECTION : PHILOSOPHIE ANTIQUE
     ═══════════════════════════════════════════════════════════════════ --&gt;
&lt;div id=&quot;Antique&quot; style=&quot;margin: 30px 0 15px 0; padding-bottom: 6px; border-bottom: 2px solid #c9a860;&quot;&gt;
&lt;span style=&quot;font-size: 1.15em; font-weight: 700; color: #6a5020; letter-spacing: 0.02em;&quot;&gt;PHILOSOPHIE ANTIQUE&lt;/span&gt;
&lt;span style=&quot;font-size: 0.85em; color: #999; margin-left: 12px;&quot;&gt;VIᵉ siècle av. J.-C. au Vᵉ siècle&lt;/span&gt;
&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- PRÉSOCRATIQUES --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #faf6ed, #f2ebdc); border:1px solid #d4c090; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a4a20; margin-bottom:8px;&quot;&gt;🌅 [[Philosophie/Présocratiques|Présocratiques]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Les premiers penseurs grecs cherchent le principe (''archè'') de toutes choses.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #d4c090; padding-top:8px;&quot;&gt;
→ [[Philosophie/Thalès de Milet|Thalès de Milet]]&lt;br/&gt;
→ [[Philosophie/Anaximandre de Milet|Anaximandre]]&lt;br/&gt;
→ [[Dictionnaire de philosophie/Empédocle|Empédocle]]&lt;br&gt;
→ [[Dictionnaire de philosophie/Anaxagore|Anaxagore]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- PLATON --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #fdf8ed, #f6eedc); border:1px solid #d4b860; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a4800; margin-bottom:8px;&quot;&gt;📜 [[Pour lire Platon|Platon]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Théorie des Idées, dialectique et fondation de l'Académie.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #d4b860; padding-top:8px;&quot;&gt;
→ [[Pour lire Platon/Guide des dialogues/Apologie de Socrate|Apologie de Socrate]]&lt;br/&gt;
→ [[Pour lire Platon/Guide des dialogues/Ion|Ion]]&lt;br/&gt;
→ [[Pour lire Platon/Vocabulaire|Vocabulaire platonicien]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- STOÏCIENS --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f8f4e8, #f0e8d8); border:1px solid #c8b070; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a4820; margin-bottom:8px;&quot;&gt;🏛️ Stoïcisme&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Vivre selon la nature, maîtriser ses passions, accepter le destin.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #c8b070; padding-top:8px;&quot;&gt;
→ [[Les Stoïciens : Épictète Le poignard à la main|Épictète]]
&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- ARISTOTE --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #fdf9ee, #f6efdb); border:1px solid #d4b860; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a4800; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Aristote|Aristote]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;384-322 av. J.-C.&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Logique, métaphysique, éthique : l'élève de Platon fonde le Lycée et met en ordre le savoir.&lt;/div&gt;
&lt;/td&gt;

&lt;!-- SCEPTICISME ANTIQUE --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f8f4e8, #f0e8d8); border:1px solid #c8b070; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a4820; margin-bottom:8px;&quot;&gt;⚖️ [[Dictionnaire de philosophie/Scepticisme|Scepticisme antique]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Suspendre le jugement (''épochè'') pour délivrer l'esprit de l'inquiétude.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #c8b070; padding-top:8px;&quot;&gt;
→ [[Dictionnaire de philosophie/Pyrrhon d'Élis|Pyrrhon d'Élis]]&lt;br/&gt;
→ [[Dictionnaire de philosophie/Carnéade|Carnéade]]
&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- ═══════════════════════════════════════════════════════════════════
     SECTION : PHILOSOPHIE MODERNE
     ═══════════════════════════════════════════════════════════════════ --&gt;
&lt;div id=&quot;Moderne&quot; style=&quot;margin: 35px 0 15px 0; padding-bottom: 6px; border-bottom: 2px solid #4a90b8;&quot;&gt;
&lt;span style=&quot;font-size: 1.15em; font-weight: 700; color: #2a5a7a; letter-spacing: 0.02em;&quot;&gt;PHILOSOPHIE MODERNE&lt;/span&gt;
&lt;span style=&quot;font-size: 0.85em; color: #999; margin-left: 12px;&quot;&gt;XVIᵉ au XVIIIᵉ siècle&lt;/span&gt;
&lt;/div&gt;

&lt;!-- Sous-section : XVIIe siècle --&gt;
&lt;div style=&quot;font-size: 0.9em; font-weight: 600; color: #4a6a85; margin: 20px 0 12px 0; padding-left: 10px; border-left: 3px solid #a0c0d8;&quot;&gt;XVIIᵉ siècle : l'âge classique&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- DESCARTES --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #eef4f8, #e0ecf4); border:1px solid #6090b8; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#1a4a6a; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/René Descartes|René Descartes]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1596-1650&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Le ''cogito'', le doute méthodique et la fondation de la philosophie moderne.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #6090b8; padding-top:8px;&quot;&gt;
→ [[Méditations métaphysiques]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- SPINOZA --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #edf5f2, #dfeee8); border:1px solid #5a9878; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#1a5038; margin-bottom:4px;&quot;&gt;Baruch Spinoza&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1632-1677&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Substance unique, déterminisme et béatitude par la connaissance.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #5a9878; padding-top:8px;&quot;&gt;
→ [[Commentaire de l'Éthique]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- PASCAL --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f5f0f8, #ebe4f2); border:1px solid #8878a8; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#3a2860; margin-bottom:4px;&quot;&gt;Blaise Pascal&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1623-1662&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Misère et grandeur de l'homme, le pari, la condition humaine.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #8878a8; padding-top:8px;&quot;&gt;
→ [[Philosophie/Commentaire du passage à propos de l'Homme esclave du divertissement|Le divertissement]]&lt;br/&gt;
→ [[Philosophie/Commentaire du passage à propos des deux infinis|Les deux infinis]]
&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- Sous-section : XVIIIe siècle --&gt;
&lt;div style=&quot;font-size: 0.9em; font-weight: 600; color: #4a6a85; margin: 25px 0 12px 0; padding-left: 10px; border-left: 3px solid #a0c0d8;&quot;&gt;XVIIIᵉ siècle : les Lumières&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- HUME --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f0f5f8, #e2eef5); border:1px solid #5088b0; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#1a4a68; margin-bottom:4px;&quot;&gt;David Hume&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1711-1776&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Empirisme intégral, critique de la causalité et scepticisme modéré.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #5088b0; padding-top:8px;&quot;&gt;
→ [[Philosophie/Vocabulaire/David Hume|Vocabulaire]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- KANT --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #eef2f8, #e0e8f2); border:1px solid #6080a8; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#2a3860; margin-bottom:4px;&quot;&gt;Emmanuel Kant&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1724-1804&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Révolution copernicienne, critique de la raison et impératif catégorique.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #6080a8; padding-top:8px;&quot;&gt;
→ [[Philosophie/Vocabulaire/Kant|Vocabulaire]]&lt;br/&gt;
→ [[Commentaire de la Fondation de la métaphysique des mœurs|Fondation de la métaphysique des mœurs]]
&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- LA METTRIE --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f2f6f0, #e6efe4); border:1px solid #6a9868; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#1a4a30; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Julien Offray de La Mettrie|Julien Offray de La Mettrie]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1709-1751&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Le matérialisme conséquent : l'homme comme machine, la pensée comme fonction du corps.&lt;/div&gt;
&lt;/td&gt;

&lt;!-- CHAMFORT --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f6f2ee, #eee6dc); border:1px solid #b09070; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a3d20; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Chamfort|Chamfort]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1740-1794&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Moraliste des Lumières finissantes : maximes et anecdotes sur la société et le pouvoir.&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- ═══════════════════════════════════════════════════════════════════
     SECTION : PHILOSOPHIE CONTEMPORAINE
     ═══════════════════════════════════════════════════════════════════ --&gt;
&lt;div id=&quot;Contemporaine&quot; style=&quot;margin: 35px 0 15px 0; padding-bottom: 6px; border-bottom: 2px solid #9070b0;&quot;&gt;
&lt;span style=&quot;font-size: 1.15em; font-weight: 700; color: #5a3d7a; letter-spacing: 0.02em;&quot;&gt;PHILOSOPHIE CONTEMPORAINE&lt;/span&gt;
&lt;span style=&quot;font-size: 0.85em; color: #999; margin-left: 12px;&quot;&gt;XIXᵉ au XXIᵉ siècle&lt;/span&gt;
&lt;/div&gt;

&lt;!-- Sous-section : XIXe siècle --&gt;
&lt;div style=&quot;font-size: 0.9em; font-weight: 600; color: #6a5080; margin: 20px 0 12px 0; padding-left: 10px; border-left: 3px solid #c0a8d0;&quot;&gt;XIXᵉ siècle&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- NIETZSCHE --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f8f0f2, #f0e4e8); border:1px solid #a87080; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#5a2838; margin-bottom:4px;&quot;&gt;[[Philosophie/Nietzsche|Friedrich Nietzsche]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1844-1900&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Critique de la morale, volonté de puissance, mort de Dieu et éternel retour.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #a87080; padding-top:8px;&quot;&gt;
→ [[Dictionnaire de philosophie/Friedrich Nietzsche|Article du Dictionnaire]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- MARX --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f7f0ec, #efe2d8); border:1px solid #b07850; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#6a3818; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Karl Marx|Karl Marx]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1818-1883&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Matérialisme historique, critique de l'économie politique et théorie de l'aliénation.&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- STIRNER --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f4f1f6, #e9e3ee); border:1px solid #8878a0; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#3a2858; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Max Stirner|Max Stirner]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1806-1856&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Contre Dieu, l'État et l'Homme abstrait : l'Unique et sa propriété.&lt;/div&gt;
&lt;/td&gt;

&lt;!-- KROPOTKINE --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f1f4f2, #e3ebe6); border:1px solid #5a9878; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#1a5038; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Pierre Kropotkine|Pierre Kropotkine]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1842-1921&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;L'entraide comme facteur de l'évolution : une anarchie fondée sur les sciences.&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- Sous-section : XXe siècle --&gt;
&lt;div style=&quot;font-size: 0.9em; font-weight: 600; color: #6a5080; margin: 25px 0 12px 0; padding-left: 10px; border-left: 3px solid #c0a8d0;&quot;&gt;XXᵉ siècle&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- HEIDEGGER --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f3eef8, #e8e0f2); border:1px solid #8068a0; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#3a2858; margin-bottom:4px;&quot;&gt;Martin Heidegger&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1889-1976&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6; margin-bottom:10px;&quot;&gt;Question de l'être, ''Dasein'', temporalité et critique de la métaphysique.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #8068a0; padding-top:8px;&quot;&gt;
→ [[Être et Temps]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- MERLEAU-PONTY --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #eef4f6, #dfebf0); border:1px solid #5088a0; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#1a4858; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Maurice Merleau-Ponty|Maurice Merleau-Ponty]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1908-1961&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;La phénoménologie du corps : nous habitons le monde avant de le penser.&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- Sous-section : Tradition analytique --&gt;
&lt;div style=&quot;font-size: 0.9em; font-weight: 600; color: #6a5080; margin: 25px 0 12px 0; padding-left: 10px; border-left: 3px solid #c0a8d0;&quot;&gt;Tradition analytique (XXᵉ et XXIᵉ siècle)&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- SCHLICK --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #eef2f8, #e0e8f2); border:1px solid #6080a8; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#2a3860; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Moritz Schlick|Moritz Schlick]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1882-1936&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Fondateur du Cercle de Vienne : vérification, sens et positivisme logique.&lt;/div&gt;
&lt;/td&gt;

&lt;!-- QUINE --&gt;
&lt;td style=&quot;width:50%; vertical-align:top; position:relative; background:linear-gradient(180deg, #eef2f8, #e0e8f2); border:1px solid #6080a8; border-radius:8px; padding:16px 18px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1.05em; color:#2a3860; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Willard Van Orman Quine|Willard Van Orman Quine]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;1908-2000&lt;/div&gt;
&lt;div style=&quot;font-size:0.88em; color:#555; line-height:1.6;&quot;&gt;Contre la distinction analytique/synthétique : holisme et naturalisation du savoir.&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- NAGEL --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f0f2f8, #e5e8f2); border:1px solid #7080a0; border-radius:8px; padding:14px 16px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1em; color:#2a3860; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Thomas Nagel|Thomas Nagel]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;né en 1937&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#555; line-height:1.5;&quot;&gt;« Quel effet cela fait-il d'être une chauve-souris ? » : subjectivité et conscience.&lt;/div&gt;
&lt;/td&gt;

&lt;!-- CHALMERS --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f0f2f8, #e5e8f2); border:1px solid #7080a0; border-radius:8px; padding:14px 16px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1em; color:#2a3860; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/David Chalmers|David Chalmers]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;né en 1966&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#555; line-height:1.5;&quot;&gt;Le « problème difficile » de la conscience et le dualisme naturaliste.&lt;/div&gt;
&lt;/td&gt;

&lt;!-- WILLIAMSON --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f0f2f8, #e5e8f2); border:1px solid #7080a0; border-radius:8px; padding:14px 16px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1em; color:#2a3860; margin-bottom:4px;&quot;&gt;[[Dictionnaire de philosophie/Timothy Williamson|Timothy Williamson]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.8em; color:#888; margin-bottom:8px;&quot;&gt;né en 1955&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#555; line-height:1.5;&quot;&gt;Le vague, les limites du savoir et la méthode de la philosophie.&lt;/div&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- Sous-section : Courants --&gt;
&lt;div style=&quot;font-size: 0.9em; font-weight: 600; color: #6a5080; margin: 25px 0 12px 0; padding-left: 10px; border-left: 3px solid #c0a8d0;&quot;&gt;Courants philosophiques&lt;/div&gt;

&lt;table style=&quot;width:100%; border-collapse:separate; border-spacing:12px;&quot;&gt;
&lt;tr&gt;
&lt;!-- PHILOSOPHIE ANALYTIQUE --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; position:relative; background:linear-gradient(180deg, #f0f2f8, #e5e8f2); border:1px solid #7080a0; border-radius:8px; padding:14px 16px; overflow:hidden;&quot;&gt;
&lt;div style=&quot;font-weight:bold; font-size:1em; color:#2a3860; margin-bottom:6px;&quot;&gt;🔬 [[Philosophie analytique]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#555; line-height:1.5; margin-bottom:10px;&quot;&gt;Analyse logique du langage et clarification des concepts.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; color:#666; border-top:1px dashed #8068a0; padding-top:8px;&quot;&gt;
→ [[Ignorance: A Case for Scepticism]]
&lt;/div&gt;
&lt;/td&gt;

&lt;!-- Placeholders pour futurs courants --&gt;
&lt;td style=&quot;width:33%; vertical-align:top; background: #fafafa; border: 1px dashed #ccc; border-radius:8px; padding:14px 16px; color: #999; font-size: 0.85em; text-align: center;&quot;&gt;
''À venir : Phénoménologie''
&lt;/td&gt;

&lt;td style=&quot;width:33%; vertical-align:top; background: #fafafa; border: 1px dashed #ccc; border-radius:8px; padding:14px 16px; color: #999; font-size: 0.85em; text-align: center;&quot;&gt;
''À venir : Existentialisme''
&lt;/td&gt;
&lt;/tr&gt;
&lt;/table&gt;

&lt;!-- ═══════════════════════════════════════════════════════════════════
     SECTION : BIBLIOGRAPHIE
     ═══════════════════════════════════════════════════════════════════ --&gt;
&lt;div id=&quot;Bibliographie&quot; style=&quot;margin: 35px 0 15px 0; padding-bottom: 6px; border-bottom: 2px solid #888;&quot;&gt;
&lt;span style=&quot;font-size: 1.15em; font-weight: 700; color: #444; letter-spacing: 0.02em;&quot;&gt;BIBLIOGRAPHIE&lt;/span&gt;
&lt;span style=&quot;font-size: 0.85em; color: #999; margin-left: 12px;&quot;&gt;Ouvrages de référence&lt;/span&gt;
&lt;/div&gt;

&lt;div style=&quot;background: linear-gradient(180deg, #fafafa, #f5f5f5); border: 1px solid #e0e0e0; border-radius: 8px; padding: 18px 22px; font-size: 0.92em; line-height: 1.8; color: #444;&quot;&gt;
&lt;div style=&quot;margin-bottom: 8px;&quot;&gt;📚 &lt;strong&gt;PRADEAU&lt;/strong&gt;, Jean-François (dir.), ''Histoire de la philosophie'', Éditions du Seuil, 2009&lt;/div&gt;
&lt;div style=&quot;margin-bottom: 8px;&quot;&gt;📚 &lt;strong&gt;CHÂTELET&lt;/strong&gt;, François, ''Histoire de la philosophie'', 8 tomes, Paris, Hachette-Pluriel, 1999-2000&lt;/div&gt;
&lt;div style=&quot;margin-bottom: 8px;&quot;&gt;📚 &lt;strong&gt;BRÉHIER&lt;/strong&gt;, Émile, ''Histoire de la philosophie'', PUF, Quadrige, 2004, {{ISBN|2-13054-396-0}}. [http://classiques.uqac.ca/classiques/brehier_emile/brehier_emile.html Texte en ligne]&lt;/div&gt;
&lt;div&gt;📚 &lt;strong&gt;ZARADER&lt;/strong&gt;, Jean-Pierre (dir.), ''Le vocabulaire des philosophes'', 5 tomes, Paris, Ellipses, 2002-2006&lt;/div&gt;
&lt;/div&gt;

&lt;!-- ═══════════════════════════════════════════════════════════════════
     FOOTER : RESSOURCES
     ═══════════════════════════════════════════════════════════════════ --&gt;
&lt;div style=&quot;margin-top: 25px; background: linear-gradient(180deg, #f5f5f3, #eaeae8); border: 1px solid #d8d8d5; border-radius: 8px; padding: 16px 20px;&quot;&gt;
&lt;div style=&quot;font-size: 0.8em; font-weight: 700; color: #555; text-transform: uppercase; letter-spacing: 0.08em; margin-bottom: 10px;&quot;&gt;Voir aussi&lt;/div&gt;
&lt;div style=&quot;font-size: 0.9em; color: #444; line-height: 1.7;&quot;&gt;
[[Philosophie|Portail Philosophie]] &amp;nbsp;•&amp;nbsp;
[[Dictionnaire de philosophie|Dictionnaire des concepts]] &amp;nbsp;•&amp;nbsp;
[[Manuel de terminale de philosophie|Manuel de Terminale]] &amp;nbsp;•&amp;nbsp;
[[w:Histoire de la philosophie|Wikipédia]]
&lt;/div&gt;
&lt;/div&gt;

[[Catégorie:Discipline philosophique]]
[[Catégorie:Histoire|Histoire de la philosophie]]
[[Catégorie:Histoire de la philosophie|*]]</text>
      <sha1>kdybjdgufc34masjcpcmiwxzzzfdv3m</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Commentaire philosophique</title>
    <ns>14</ns>
    <id>3800</id>
    <revision>
      <id>769253</id>
      <parentid>765035</parentid>
      <timestamp>2026-07-01T03:38:58Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769253</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="75" sha1="cj2u2j2xk5fi61dz1zdljj1pklfi1jv" xml:space="preserve">[[catégorie:Philosophie]]
[[Catégorie:Commentaire philosophique (livre)]]</text>
      <sha1>cj2u2j2xk5fi61dz1zdljj1pklfi1jv</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Philosophie</title>
    <ns>14</ns>
    <id>3802</id>
    <revision>
      <id>769268</id>
      <parentid>765030</parentid>
      <timestamp>2026-07-01T04:27:54Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769268</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="568" sha1="im93h2aq74jgqauc0icegss3na9qqit" xml:space="preserve">{{Méta lien portail|couleur tour=#B08C7B|couleur fond=#7BB08C|
image=Owl of Minerva.png|taille image=25|
texte=[[Philosophie]] : accédez à tous les livres de philosophie de Wikilivres.
}}
{{autres projets|commons=Category:Philosophy|  s            = Portail:Philosophie}}

Cette catégorie rassemble les livres, cours et ressources de philosophie de Wikilivres, ainsi que les sous-catégories qui les organisent : ouvrages de référence, cours d'initiation, commentaires de textes et études thématiques.

[[Catégorie:Classe 1 - Philosophie et psychologie‎|*]]</text>
      <sha1>im93h2aq74jgqauc0icegss3na9qqit</sha1>
    </revision>
    <revision>
      <id>769269</id>
      <parentid>769268</parentid>
      <timestamp>2026-07-01T04:44:35Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769269</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1327" sha1="7nfq0nn7hm1q6pncqdtix6qntxup7mv" xml:space="preserve">&lt;div style=&quot;display:flex; align-items:center; margin:0 0 1em 0; padding:12px 18px; background:linear-gradient(135deg,#f6efdc,#eaddba); border:2px solid #cbaa62; border-radius:16px; box-shadow:0 1px 4px rgba(0,0,0,0.15); overflow:hidden;&quot;&gt;
&lt;div style=&quot;flex:0 0 auto; margin-right:14px;&quot;&gt;[[Fichier:Owl of Minerva.png|46px|Chouette de Minerve|link=Philosophie]]&lt;/div&gt;
&lt;div style=&quot;flex:1 1 auto; min-width:0;&quot;&gt;
&lt;div style=&quot;font-size:1.5em; font-weight:700; letter-spacing:0.03em; line-height:1.15;&quot;&gt;[[Philosophie|&lt;span style=&quot;color:#6a5218;&quot;&gt;Philosophie&lt;/span&gt;]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.92em; color:#7c6636; margin-top:3px;&quot;&gt;De Platon à la philosophie analytique&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; margin-top:9px;&quot;&gt;
[[Philosophie/Histoire de la philosophie|Histoire de la philosophie]]&amp;nbsp;&amp;nbsp;·&amp;nbsp;&amp;nbsp;[[Dictionnaire de philosophie|Dictionnaire]]&amp;nbsp;&amp;nbsp;·&amp;nbsp;&amp;nbsp;[[Manuel de terminale de philosophie|Manuel de terminale]]
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{{autres projets|commons=Category:Philosophy|s=Portail:Philosophie}}

Cette catégorie rassemble les livres, cours et ressources de philosophie de Wikilivres, ainsi que les sous-catégories qui les organisent : ouvrages de référence, cours d'initiation, commentaires de textes et études thématiques.

[[Catégorie:Classe 1 - Philosophie et psychologie‎|*]]</text>
      <sha1>7nfq0nn7hm1q6pncqdtix6qntxup7mv</sha1>
    </revision>
    <revision>
      <id>769270</id>
      <parentid>769269</parentid>
      <timestamp>2026-07-01T04:56:25Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769270</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1345" sha1="nxtetqa11tyxbmufrqe5i43l1ly0b0w" xml:space="preserve">&lt;div style=&quot;display:flex; align-items:center; margin:0 0 1em 0; padding:12px 18px; background:linear-gradient(135deg,#f1eaf4,#ddc9e6); border:2px solid #8f6ba6; border-radius:16px; box-shadow:0 1px 4px rgba(0,0,0,0.15); overflow:hidden;&quot;&gt;
&lt;div style=&quot;flex:0 0 auto; margin-right:14px;&quot;&gt;[[Fichier:Owl of Minerva.png|46px|Chouette de Minerve|link=Philosophie]]&lt;/div&gt;
&lt;div style=&quot;flex:1 1 auto; min-width:0;&quot;&gt;
&lt;div style=&quot;font-size:1.5em; font-weight:700; letter-spacing:0.03em; line-height:1.15;&quot;&gt;[[Philosophie|&lt;span style=&quot;color:#4a2c62;&quot;&gt;Philosophie&lt;/span&gt;]]&lt;/div&gt;
&lt;div style=&quot;font-size:0.92em; color:#5c3f74; margin-top:3px;&quot;&gt;De Platon à la philosophie analytique, en libre accès.&lt;/div&gt;
&lt;div style=&quot;font-size:0.85em; margin-top:9px;&quot;&gt;
[[Philosophie/Histoire de la philosophie|Histoire de la philosophie]]&amp;nbsp;&amp;nbsp;·&amp;nbsp;&amp;nbsp;[[Dictionnaire de philosophie|Dictionnaire]]&amp;nbsp;&amp;nbsp;·&amp;nbsp;&amp;nbsp;[[Manuel de terminale de philosophie|Manuel de terminale]]
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{{autres projets|commons=Category:Philosophy|s=Portail:Philosophie}}

Cette catégorie rassemble les livres, cours et ressources de philosophie de Wikilivres, ainsi que les sous-catégories qui les organisent : ouvrages de référence, cours d'initiation, commentaires de textes et études thématiques.

[[Catégorie:Classe 1 - Philosophie et psychologie‎|*]]</text>
      <sha1>nxtetqa11tyxbmufrqe5i43l1ly0b0w</sha1>
    </revision>
  </page>
  <page>
    <title>Grec ancien/Dieux</title>
    <ns>0</ns>
    <id>29805</id>
    <revision>
      <id>769271</id>
      <parentid>768170</parentid>
      <timestamp>2026-07-01T06:48:05Z</timestamp>
      <contributor>
        <username>~2026-34862-02</username>
        <id>124042</id>
      </contributor>
      <comment>/* Liste détaillée */</comment>
      <origin>769271</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3513" sha1="lj01kpq6fewsaxfhjuiaubddvpyxybh" xml:space="preserve">{{Grec ancien}}

Il existe un très grand nombre de dieux grecs. ([[w:Généalogie de la mythologie grecque|les listes]] en font état de plus de 200) Ceux-ci sont tous classés selon leur famille :
*Les Ancêtres (Chaos, Gaïa, Ouranos)
*Descendants d'Ouranos et de Gaïa (Aphrodite, Molios, Théomisès)
*Géants (Cerbère, Chimère, Sphinx, Orthos)
*Descendance des Titans et des Titanides (Thémis, Pirène, Batia)
*Descendants des monstres (Cyclope)
*Descendants de Pontos (Amphitrite, Achille, Néréïdes)
*Descendants d'Éros
*Descendants d'Erèbe
*Descendants de Nyx
*Descendants de Tartare
*Descendants de Python
*Descendants d'Amythaon
*Descendants d'Idmon
*Descendants de Strophios
*Descendants de Plégias
*Nymphes
''Il existe de nombreuses sous-familles. En raison de leur nombre, nous n'en ferons pas état ici.''

== Les divinités Olympiennes ==
[[Fichier:Mytikas summit PJS.jpg|left|thumb|Le mont Olympe.]]

[[Fichier:Sarcophagus Prometheus Louvre Ma339.jpg|thumb|center|370px|Le cortège des dieux de l'Olympe. Sarcophage romain, vers 240 ap. J.-C., Musée du Louvre, Paris, France.]]

Les divinités Olympiennes, au nombre de 12, sont les dieux grecs qui vivent sur le mont Olympe. Ce nombre varie selon les siècles ; on y retrouve toujours Zeus, Héra, Poséidon, Arès, Hermès, Héphaïstos, Athéna, Apollon et Artémis qui sont complétés par Hestia, Déméter, Aphrodite, Dionysos et Hadès en fonction des époques.

== Liste détaillée ==
** [[/Aidos/]]
** [[/Aléthée/|Althée]]
** [[/Ananké/]]
** [[/Antéros/]]
** [[/Apaté/]]
** [[/Apollon/]]
** [[/Aphrodite/]]
** [[/Arès/]]
** [[/Arété/]]
** [[/Artémis/]]
** [[/Asclépios/]]
** [[/Até/]]
** [[/Athéna/]]
** [[/Chronos/]]
** [[/Cronos/]]
** [[/Coros/]]
** [[/Cybèle/]]
** [[/Déimos/]]
** [[/Déméter/]]
** [[/Dicé/]]
** [[/Dionysos/]]
** [[/Dolos/]]
** [[/Dysnomie/]]
** [[/Dyssebeia/]]
** [[/Dyssébie/]]
** [[/Eiréné/]]
** [[/Eunomie/]]
** [[/Eusébie/]]
** [[/Éléos/]]
** [[/Elpis/]]
** [[/Éole/]]
** [[/Éosphoros/]]
** [[/Éos/]]
** [[/Érèbe/]]
** [[/Éris/]]
** [[/Éros/]]
** [[/Ésa/]]
** [[/Gaïa/]]
** [[/Géras/]]
** [[/Harmonie/]]
** [[/Hadès/]]
** [[/Hespéros/]]
** [[/Hébé/]]
** [[/Hédoné/]]
** [[/Hédylogos/]]
** [[/Héphaïstos/]]
** [[/Héra/]]
** [[/Hermès/]]
** [[/Hestia/]]
** [[/Himéros/]]
** [[/Horkos/]]
** [[/Hybris/]]
** [[/Hygie/]]
** [[/Hypnos/]]
** [[/Hébé/]]
** [[/Hécate/]]
** [[/Hélios/]]
** [[/Héméra/]]
** [[/Hypnos/]]
** [[/Ilithyie/]]
** [[/Limos/]]
** [[/Lyssa/]]
** [[/Mania/]]
** [[/Momos/]]
** [[/Moros/]]
** [[/Métis/]]
** [[/Némésis/]]
** [[/Niké/]]
** [[/Nyx/]]
** [[/Oizys/]]
** [[/Ouranos/]]
** [[/Panacée/]]
** [[/Pan/]]
** [[/Péitho/]]
** [[/Pénia/]]
** [[/Perséphone/]]
** [[/Philotès/]]
** [[/Phobos/]]
** [[/Pistis/]]
** [[/Poséidon/]]
** [[/Pothos/]]
** [[/Rhéa/]]
** [[/Séléné/]]
** [[/Sophrosyne/]]
** [[/Thanatos/]]
** [[/Thémis/]]
** [[/Tyché/]]
** [[/Zélos/]]
** [[/Zeus/]]
** [[/Épiphron/]]

* [[../Texte : Odyssée|Texte : L'Odyssée, Livre 7]]
* [[../Exercices chapitre 4|Exercices]]

== Généalogie ==
{{Grec ancien/Arbre généalogique dieux}}

== Questions ==
{{Avertissement exercice}}
#Quelles divinités pouvez-vous reconnaître sur la fresque représentant le cortège des Dieux (§ « ''Les divinités Olymipiennes'' ») ?
{{boîte déroulante|titre=afficher les réponses|contenu=
On peut voir sur cette fresque (de gauche à droite) :
*Athéna, 
*Hermès et son pétase ailé, 
*Poséidon,
*Artémis.
}}</text>
      <sha1>lj01kpq6fewsaxfhjuiaubddvpyxybh</sha1>
    </revision>
  </page>
  <page>
    <title>Wikilivres:Compilations/Dictionnaire de philosophie</title>
    <ns>4</ns>
    <id>30507</id>
    <revision>
      <id>769258</id>
      <parentid>767521</parentid>
      <timestamp>2026-07-01T03:55:04Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769258</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7109" sha1="6d82x0z34cn1fz718da130ewpnmuxc9" xml:space="preserve">{{Compilation}}
'''Livre en cours d'écriture'''
== Dictionnaire de philosophie ==
;A
:[[Dictionnaire de philosophie/A (logique)|A]]
:[[Dictionnaire de philosophie/A priori|A priori]]
:[[Dictionnaire de philosophie/Abduction|Abduction]]
:[[Dictionnaire de philosophie/Aboulie|Aboulie]]
:[[Dictionnaire de philosophie/Absolu|Absolu]]
:[[Dictionnaire de philosophie/Absolutisme|Absolutisme]]
:[[Dictionnaire de philosophie/Abstraction|Abstraction]]
:[[Dictionnaire de philosophie/Absurde|Absurde]]
:[[Dictionnaire de philosophie/Acatalépsie|Acatalépsie]]
:[[Dictionnaire de philosophie/Accident|Accident]]
:[[Dictionnaire de philosophie/Action|Action]]
:[[Dictionnaire de philosophie/Affection|Affection]]
:[[Dictionnaire de philosophie/Agnosticisme|Agnosticisme]]
:[[Dictionnaire de philosophie/Aliénation|Aliénation]]
:[[Dictionnaire de philosophie/Altérité|Altérité]]
:[[Dictionnaire de philosophie/Altruisme|Altruisme]]
:[[Dictionnaire de philosophie/Âme|Âme]]
:[[Dictionnaire de philosophie/Amitié|Amitié]]
:[[Dictionnaire de philosophie/Amour|Amour]]
:[[Dictionnaire de philosophie/Anarchisme|Anarchisme]]
:[[Dictionnaire de philosophie/Anaxagore|Anaxagore]]
:[[Dictionnaire de philosophie/Angoisse|Angoisse]]
:[[Dictionnaire de philosophie/Animal|Animal]]
:[[Dictionnaire de philosophie/Anthropocentrisme|Anthropocentrisme]]
:[[Dictionnaire de philosophie/Antinomie|Antinomie]]
:[[Dictionnaire de philosophie/Aporie|Aporie]]
:[[Dictionnaire de philosophie/Apparence|Apparence]]
:[[Dictionnaire de philosophie/Argentine (Philosophie)|Argentine (Philosophie)]]
:[[Dictionnaire de philosophie/Argument|Argument]]
:[[Dictionnaire de philosophie/Aristote|Aristote]]
:[[Dictionnaire de philosophie/Art|Art]]
:[[Dictionnaire de philosophie/Art (introduction)|Art (introduction)]]
:[[Dictionnaire de philosophie/Art et Vérité|Art et Vérité]]
:[[Dictionnaire de philosophie/Ataraxie|Ataraxie]]
:[[Dictionnaire de philosophie/Athéisme|Athéisme]]
:[[Dictionnaire de philosophie/Atomisme|Atomisme]]
:[[Dictionnaire de philosophie/Attribut|Attribut]]
:[[Dictionnaire de philosophie/Authenticité|Authenticité]]
:[[Dictionnaire de philosophie/Autonomie|Autonomie]]
:[[Dictionnaire de philosophie/Autorité|Autorité]]
:[[Dictionnaire de philosophie/Avortement|Avortement]]
:[[Dictionnaire de philosophie/Axiome|Axiome]]
;B
:[[Dictionnaire de philosophie/Bateau de Neurath|Bateau de Neurath]]
:[[Dictionnaire de philosophie/Beau|Beau]]
:[[Dictionnaire de philosophie/Besoin|Besoin]]
:[[Dictionnaire de philosophie/Bien|Bien]]
:[[Dictionnaire de philosophie/Bioéthique|Bioéthique]]
:[[Dictionnaire de philosophie/Bonheur|Bonheur]]
;C
:[[Dictionnaire de philosophie/Carnéade|Carnéade]]
:[[Dictionnaire de philosophie/Causalité|Causalité]]
:[[Dictionnaire de philosophie/Certitude|Certitude]]
:[[Dictionnaire de philosophie/David Chalmers|Chalmers]]
:[[Dictionnaire de philosophie/Chamfort|Chamfort]]
:[[Dictionnaire de philosophie/Chine|Chine]]
:[[Dictionnaire de philosophie/Cogito|Cogito]]
:[[Dictionnaire de philosophie/Concept|Concept]]
:[[Dictionnaire de philosophie/Connaissance|Connaissance]]
:[[Dictionnaire de philosophie/Conscience|Conscience]]
:[[Dictionnaire de philosophie/Consensus|Consensus]]
:[[Dictionnaire de philosophie/Contingence|Contingence]]
:[[Dictionnaire de philosophie/Convention|Convention]]
:[[Dictionnaire de philosophie/Courage|Courage]]
:[[Dictionnaire de philosophie/Criticisme|Criticisme]]
:[[Dictionnaire de philosophie/Croyance|Croyance]]
:[[Dictionnaire de philosophie/Culture|Culture]]
;D
:[[Dictionnaire de philosophie/Dasein|Dasein]]
:[[Dictionnaire de philosophie/Décadence|Décadence]]
:[[Dictionnaire de philosophie/Découverte|Découverte]]
:[[Dictionnaire de philosophie/Déduction|Déduction]]
:[[Dictionnaire de philosophie/Définition|Définition]]
:[[Dictionnaire de philosophie/Déisme|Déisme]]
:[[Dictionnaire de philosophie/Démocratie|Démocratie]]
:[[Dictionnaire de philosophie/René Descartes|Descartes]]
:[[Dictionnaire de philosophie/Désir|Désir]]
:[[Dictionnaire de philosophie/Désobéissance|Désobéissance]]
:[[Dictionnaire de philosophie/Déterminisme|Déterminisme]]
:[[Dictionnaire de philosophie/Diallèle|Diallèle]]
:[[Dictionnaire de philosophie/Dialectique|Dialectique]]
:[[Dictionnaire de philosophie/Différence ontologique|Différence ontologique]]
:[[Dictionnaire de philosophie/Divertissement|Divertissement]]
:[[Dictionnaire de philosophie/Doute|Doute]]
:[[Dictionnaire de philosophie/Droit|Droit]]
:[[Dictionnaire de philosophie/Dualisme|Dualisme]]
;E
:[[Dictionnaire de philosophie/Égalité|Égalité]]
:[[Dictionnaire de philosophie/Émergence|Émergence]]
:[[Dictionnaire de philosophie/Empédocle|Empédocle]]
:[[Dictionnaire de philosophie/Empirisme|Empirisme]]
:[[Dictionnaire de philosophie/Épistémologie|Épistémologie]]
:[[Dictionnaire de philosophie/Erreur|Erreur]]
:[[Dictionnaire de philosophie/Esthétique dans la pensée chinoise|Esthétique dans la pensée chinoise]]
:[[Dictionnaire de philosophie/État de nature|État de nature]]
:[[Dictionnaire de philosophie/Euthanasie|Euthanasie]]
:[[Dictionnaire de philosophie/Existence|Existence]]
:[[Dictionnaire de philosophie/Expérience de pensée|Expérience de pensée]]
;F
:[[Dictionnaire de philosophie/Facticité|Facticité]]
:[[Dictionnaire de philosophie/Finitude|Finitude]]
;G
:[[Dictionnaire de philosophie/Ghana|Ghana]]
;I
:[[Dictionnaire de philosophie/Imagination|Imagination]]
:[[Dictionnaire de philosophie/Individu|Individu]]
:[[Dictionnaire de philosophie/Intelligence animale|Intelligence animale]]
;K
:[[Dictionnaire de philosophie/Pierre Kropotkine|Kropotkine]]
;L
:[[Dictionnaire de philosophie/Julien Offray de La Mettrie|La Mettrie]]
;M
:[[Dictionnaire de philosophie/Karl Marx|Marx]]
:[[Dictionnaire de philosophie/Maurice Merleau-Ponty|Merleau-Ponty]]
:[[Dictionnaire de philosophie/Métaphysique|Métaphysique]]
:[[Dictionnaire de philosophie/Monothéisme|Monothéisme]]
:[[Dictionnaire de philosophie/Morale|Morale]]
:[[Dictionnaire de philosophie/Mort|Mort]]
;N
:[[Dictionnaire de philosophie/Thomas Nagel|Nagel]]
:[[Dictionnaire de philosophie/Friedrich Nietzsche|Nietzsche]]
;P
:[[Dictionnaire de philosophie/Panthéisme|Panthéisme]]
:[[Dictionnaire de philosophie/Personne non-humaine|Personne non-humaine]]
:[[Dictionnaire de philosophie/Philosophie africaine|Philosophie africaine]]
:[[Dictionnaire de philosophie/Polythéisme|Polythéisme]]
:[[Dictionnaire de philosophie/Pyrrhon d'Élis|Pyrrhon d'Élis]]
;Q
:[[Dictionnaire de philosophie/Willard Van Orman Quine|Quine]]
;S
:[[Dictionnaire de philosophie/Scepticisme|Scepticisme]]
:[[Dictionnaire de philosophie/Moritz Schlick|Schlick]]
:[[Dictionnaire de philosophie/Max Stirner|Stirner]]
:[[Dictionnaire de philosophie/Philosophie suédoise contemporaine|Suède]]
:[[Dictionnaire de philosophie/Sujet|Sujet]]
;T
:[[Dictionnaire de philosophie/Théisme|Théisme]]
;U
:[[Dictionnaire de philosophie/Ubuntu|Ubuntu]]
;V
:[[Dictionnaire de philosophie/Vérité|Vérité]]
;W
:[[Dictionnaire de philosophie/Timothy Williamson|Williamson]]
[[Catégorie:Philosophie|*]]</text>
      <sha1>6d82x0z34cn1fz718da130ewpnmuxc9</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Pour lire Platon (livre)</title>
    <ns>14</ns>
    <id>30835</id>
    <revision>
      <id>769267</id>
      <parentid>765026</parentid>
      <timestamp>2026-07-01T04:05:36Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769267</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="179" sha1="s0qqbxgxj00ka7emm53cgj1tq2ftesd" xml:space="preserve">[[Catégorie:Livres par titre]]
[[Catégorie:Histoire de la philosophie]]
[[Catégorie:Philosophie]]
[[Catégorie:Classe 1 - Philosophie et psychologie]]
[[Catégorie:Philosophe]]</text>
      <sha1>s0qqbxgxj00ka7emm53cgj1tq2ftesd</sha1>
    </revision>
  </page>
  <page>
    <title>Philosophie/Théorie de la connaissance/Le Problème de Gettier</title>
    <ns>0</ns>
    <id>32916</id>
    <revision>
      <id>769265</id>
      <parentid>753913</parentid>
      <timestamp>2026-07-01T04:01:11Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769265</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16607" sha1="58dcyxclfxrg5ol9d9mbelra9vcmll1" xml:space="preserve">''Le problème de Gettier'' est un problème épistémologique exposé par le philosophe [[w:Edmund Gettier|Edmund Gettier]] dans un article de 1963, « Une croyance vraie et justifiée est-elle une connaissance ? » (''Is Justified True Belief Knowledge?''), publié dans la revue ''Analysis''.

Gettier propose dans cet article des contre-exemples à la thèse traditionnelle que nous avons vue dans le chapitre précédent, thèse selon laquelle les conditions d'une croyance vraie et justifiée sont nécessaires et suffisantes pour que cette croyance soit une connaissance. Autrement dit, il cherche à montrer qu’on peut posséder une croyance vraie et bien justifiée sans pour autant posséder de ''connaissance'' au sens strict.

== ''L'Importance d'être Constant'' : deux exemples intuitifs ==

Avant d'en venir au problème de Gettier proprement dit, il est utile de présenter deux exemples classiques qui fournissent un premier aperçu intuitif de la difficulté.

Dans la pièce de théâtre d’[[Oscar Wilde]], ''L'Importance d'être Constant'', Jack ment à Gwendolen en lui disant s'appeler Constant. Or, ce que Jack ignore lui-même, c'est que son vrai prénom ''est'' effectivement Constant. Peut-on dire que Gwendolen, qui ''croit'' que Jack s'appelle Constant, le ''sait'' ?

Nous pouvons dire que Gwendolen a de bonnes raisons de le croire : c'est Jack lui-même qui le lui a dit, et s’informer auprès d’une personne sur son propre prénom est une méthode courante et fiable. Il n’y a là rien d’irrationnel. En outre, ce qu’elle croit est vrai : Jack se prénomme réellement Constant. Cependant, Jack avait l’intention de mentir ; il ne savait pas lui-même que ce prénom était le sien. De ce fait, la « connaissance » de Gwendolen repose sur un concours de circonstances tout à fait fortuit. Dans ces conditions, peut-on vraiment dire qu’elle ''sait'' que le prénom de Jack est Constant ? Intuitivement, nous sommes tentés de répondre non : Gwendolen a bien une croyance vraie et raisonnable, mais cette vérité semble relever de la chance.

Bertrand Russell propose un exemple du même type : une horloge s'est arrêtée, et, vingt-quatre heures plus tard, je la regarde, ignorant qu'elle ne fonctionne plus, pour connaître l'heure. L'horloge m'indique l'heure qu'il est effectivement, puisque je la consulte exactement vingt-quatre heures après qu'elle s’est arrêtée. Pourtant, là encore, il s’agit d’une pure coïncidence : mon indication de l’heure est correcte, mais elle l’est pour de mauvaises raisons. Est-ce que je ''sais'' vraiment l'heure qu'il est ?

Ces cas, que l’on peut qualifier de « pré-gettieriens », suggèrent déjà qu’il peut exister des croyances vraies et raisonnablement soutenues qui, pourtant, ne méritent pas le nom de ''connaissance''. Ils ouvrent la question centrale : suffit-il qu’une croyance soit à la fois vraie et bien justifiée pour qu’elle soit une connaissance, ou faut-il ajouter d’autres exigences pour éliminer ce genre de coïncidences heureuses ?

== La connaissance comme croyance vraie et justifiée ==

''Pour plus de détails voir :'' [[Philosophie/Théorie de la connaissance/Une définition traditionnelle|Une définition traditionnelle de la connaissance]].

Selon la définition dite « traditionnelle », avoir une connaissance de quelque chose signifie que ce quelque chose est vrai, que l’on croit que c’est vrai et que cette croyance est justifiée. Par conséquent, connaître, c’est avoir une ''croyance vraie et justifiée''.

Prenons, pour illustrer et comprendre cette thèse, la proposition :

:La Terre est ronde.

Si cette proposition est vraie, si je crois qu'elle est vraie et si j'ai de bonnes raisons de le croire (par exemple, des voyageurs en ont fait le tour, il existe des photographies de la Terre depuis l’espace, les lois de la gravitation expliquent sa forme, etc.), alors il semble légitime de dire que je ''sais'' que la Terre est ronde.

Gettier propose de cette thèse une présentation formelle, c'est-à-dire une présentation où les termes sont remplacés par des lettres, ce qui permet de mieux mettre en évidence le caractère général de la thèse. En remplaçant le sujet par la lettre ''S'' (pour dire que l'on parle de n'importe quel sujet qui peut croire et savoir), et l'énoncé qui est cru par la lettre ''p'' (pour dire que l'on parle de n'importe quelle proposition pouvant être vraie ou fausse), Gettier écrit :

S sait que p, si et seulement si :

# p est vrai ;
# S croit que p ;
# S est justifié à croire que p.

Ces trois points sont, pris ensemble, des conditions dites ''nécessaires'' et ''suffisantes''.
Elles sont '''nécessaires''' parce que l'on ne peut pas s'en passer pour qu'une croyance soit de la connaissance ; elles sont supposées '''suffisantes''' parce qu’elles suffiraient, à elles seules, pour transformer une croyance en connaissance : il n’y aurait besoin de rien d'autre que ces trois conditions.

Cette conception de la connaissance est partagée, selon Gettier, par des auteurs comme [[w:Alfred Ayer|Alfred Ayer]] ou Roderick Chisholm, et elle est souvent attribuée, de manière discutable, à Platon. Sur ce dernier point, il est en réalité difficile de suivre Gettier, car Platon rejette explicitement cette conception dans le ''Théétète''. Mais cette dispute historique n’a pas d’importance décisive pour la compréhension du problème lui-même.

=== Pourquoi les trois conditions sont nécessaires ===

Les trois conditions sont nécessaires, parce que si l'une d'elles n'est pas remplie, on ne peut pas parler de connaissance.

Cela est évident pour le premier point : il serait contradictoire de dire que « savoir que p » est une forme de connaissance, alors que p est faux. Par exemple, si je crois que la Terre est plate et que la Terre ne l’est pas, ce que je crois n'est pas un savoir, mais une erreur. Donc, si je crois que p est vrai et si p est faux, alors je ne ''sais'' pas que p.

La deuxième condition présente la même évidence. Si « la Terre est ronde » est une proposition vraie, mais que je ne crois pas qu’elle le soit, je n’ai pas de connaissance, mais je suis dans l’ignorance ou dans la suspension de jugement. Une vérité que je ne reconnais pas ne devient pas pour autant un savoir que je posséderais.

La troisième condition est plus subtile. Si « la Terre est ronde » est une proposition vraie, et si je crois qu'elle est vraie, je peux malgré tout ne pas être justifié à le croire, si mes raisons sont mauvaises. Par exemple, je crois que la Terre est ronde parce que je crois que c’est ainsi que le Grand Bélier primordial l’a créée, et je n’ai aucune raison sérieuse d’accorder foi à cette croyance cosmologique. S’il l’avait créée autrement, je n’aurais pas cru que la Terre est ronde, quand bien même il est vrai qu’elle l’est. Autrement dit, si mes raisons de croire sont inappropriées ou fausses, elles ne permettent pas vraiment d'''expliquer'' pourquoi ma croyance est vraie ; sa vérité relève alors de la coïncidence, même si, par chance, la proposition à laquelle je crois est exacte.

Pour que ma croyance soit justifiée, je dois donc pouvoir donner un ''bon'' récit de la manière dont je suis parvenu à cette croyance et montrer en quoi ce récit rend plausible sa vérité : elle ne doit pas être tenue simplement de la rumeur, de traditions infondées ou de ouï-dire. Cela suppose de recourir à d'autres croyances, provenant par exemple d'une expérience directe ou indirecte (p. ex. je crois que je suis né à tel endroit parce que mes parents me l’ont dit et que des documents le confirment), ou encore à un ensemble de propositions vraies et justifiées (par exemple une théorie scientifique) à partir desquelles ma croyance peut être déduite à bon droit ou dont elle est une bonne conséquence.

Jusqu’ici, rien ne semble contredire l’idée que « connaissance = croyance vraie justifiée ». C’est ce socle que les contre-exemples de Gettier vont faire vaciller.

== Contre-exemples ==

Ce que Gettier remet en cause, ce n’est pas le caractère nécessaire des trois conditions, mais leur ''suffisance''. Affirmer qu’elles sont suffisantes revient à dire que, dès qu’elles sont remplies, on est obligé de considérer la croyance comme une connaissance, et qu’il n’est besoin d’aucune condition supplémentaire. Donc, si les trois conditions énoncées dans la section précédente sont satisfaites, toute croyance vraie et justifiée devrait être une connaissance.

Voyons maintenant l'insuffisance de ces conditions avec le premier contre-exemple proposé par Gettier.

Smith et Jones sont tous les deux candidats à un certain emploi. Smith a de bonnes raisons de croire que :

1. Jones est celui qui sera embauché, car le directeur de l'entreprise le lui a dit ;&lt;br&gt;
2. Jones a dix pièces dans sa poche, car Smith les a comptées.

À partir de 1) et 2), Smith peut donc en déduire (de manière apparemment légitime) que :

:3) Celui qui sera embauché a dix pièces dans sa poche.

Mais supposons que la situation réelle soit la suivante :

:Smith est finalement embauché ;
:Smith a lui aussi, mais sans le savoir, dix pièces dans sa poche.

Il est alors toujours vrai que :

:Celui qui sera embauché a dix pièces dans sa poche.

Dans cet exemple, la proposition 3 est vraie, Smith croit qu'elle est vraie et a de bonnes raisons (par 1 et 2) de la croire vraie ; cependant, il semble clair que Smith ne ''sait'' pas que la proposition 3 est vraie. Sa croyance est vraie et justifiée, mais elle est vraie ''par hasard'' : elle repose sur une prémisse fausse (que Jones sera embauché), et c’est seulement par coïncidence que cette déduction aboutit à une vérité.

On dit parfois que les cas de Gettier reposent sur une ''justification défectueuse'' : le sujet raisonne correctement, mais à partir d’au moins une croyance fausse. Le résultat de ce raisonnement peut être vrai, mais pour de mauvaises raisons.

Revenons à présent aux deux exemples de la première section, et appliquons-leur la formalisation de Gettier, pour voir s’ils entrent dans ce schéma.

Gwendolen sait que le prénom de Jack est Constant, si et seulement si :

# Il est vrai que le prénom de Jack est Constant.
# Gwendolen croit qu'il est vrai que le prénom de Jack est Constant.
# Gwendolen est justifiée à croire que le prénom de Jack est Constant, car Jack le lui a dit.

Je sais l'heure qu'il est (admettons qu'il soit 14 heures), si et seulement si :

# Il est vrai qu'il est 14 heures.
# Je crois qu'il est vrai qu'il est 14 heures.
# Je suis justifié à croire qu'il est 14 heures, car il est raisonnable de regarder une horloge pour connaître l'heure.

On voit que les deux exemples correspondent parfaitement à cette conception de la connaissance. Toutes les conditions sont remplies : la croyance est vraie, elle est crue, et elle semble raisonnablement soutenue par de bonnes raisons. Pourtant, comme pour le cas de Smith, il paraît difficile de considérer que la croyance de Gwendolen ou la mienne à propos de l’heure soit une véritable connaissance. Dans les deux cas, la vérité de la croyance est liée à un heureux hasard : c’est ''accidentellement'' que la croyance vraie coïncide avec la réalité.

À la suite de la publication de l'article de Gettier, il est apparu qu'il existe de nombreux « cas de Gettier », soit que ces cas soient laborieusement inventés par des philosophes (et, dans ce cas, il faut avouer qu'ils sont parfois quelque peu tirés par les cheveux, même s'ils restent possibles), soit qu'ils puissent se présenter de manière tout à fait vraisemblable dans la vie quotidienne, comme l'exemple de l'horloge. En réalité, il n'est pas difficile de fabriquer ce genre de scénarios : il suffit que le sujet raisonne correctement à partir d’une prémisse fausse, et que, par une coïncidence heureuse, la conclusion à laquelle il parvient soit néanmoins vraie.

== Bilan : que nous apprend le problème de Gettier ? ==

Le problème de Gettier réfute la conception classique de la connaissance, au sens où il montre que la triple condition « croyance vraie justifiée » n’est pas suffisante. Les difficultés qu’il met en lumière ont engendré une abondante littérature en [[épistémologie]] contemporaine.

La leçon minimale à en tirer est la suivante : même si une croyance est vraie, sincèrement tenue, et appuyée sur des raisons qui paraissent bonnes au sujet, il peut toujours être légitime de dire qu’elle ne constitue pas encore une ''connaissance''. Il y a quelque chose de plus dans la connaissance qui manque dans les cas de Gettier, et ce « quelque chose » a souvent été décrit comme l’absence de ''chance épistémique'' : dans un véritable savoir, la vérité de la croyance ne doit pas être le fruit d’un hasard heureux.

Que faire alors de la condition de justification ? Faut-il la réviser — et, dans ce cas, de quelle manière ? — ou doit-on ajouter une (ou plusieurs) nouvelle(s) condition(s) afin de rendre l'ensemble des conditions véritablement suffisantes ?

Les réponses proposées dans la littérature se répartissent schématiquement en plusieurs grandes familles :

* Certaines tentatives modifient la troisième condition en exigeant, par exemple, que la justification ne passe par aucune prémisse fausse (théories dites « sans prémisses fausses ») ou qu’elle soit « non trompée ».
* D’autres ajoutent une condition supplémentaire, par exemple que la croyance soit reliée de manière ''causale'' au fait qu’elle énonce (théories causales de la connaissance), ou que la méthode par laquelle on forme la croyance soit généralement fiable (fiabilisme).
* D’autres encore abandonnent l’idée même que la connaissance soit un simple « paquet » de conditions sur la croyance, et la pensent plutôt comme une capacité, une compétence, ou une relation plus riche entre le sujet et le monde.

Il n’y a pas de consensus définitif sur la « bonne » solution. Ce qui fait l’importance durable du problème de Gettier, c’est moins la forme technique de ses exemples que la mise à nu d’une tension profonde : nous voulons, d’un côté, une conception de la connaissance qui tienne compte de nos raisons et de nos justifications, mais, de l’autre, nous refusons de considérer comme ''savoir'' des croyances vraies qui doivent trop à la chance.

== Exercices ==

* Dans ce chapitre, qu'est-ce que nous tenons pour vrai ?

# un savoir ?
# des propositions ?
# des croyances ?

* Une croyance vraie et justifiée peut-elle, dans certains cas, ne pas être de la connaissance ? Expliquez en vous appuyant sur un exemple (ou en inventant un cas de type Gettier).
* À quelles conditions sommes-nous justifiés à tenir une croyance pour vraie ? Ces conditions suffisent-elles pour écarter tout rôle du hasard ?
* Peut-on définir la connaissance comme simple croyance vraie et supprimer ainsi la troisième condition (la justification) ? Que deviendraient alors les cas de Gettier ?

== Bibliographie ==

* Edmund L. Gettier, « Is Justified True Belief Knowledge? », ''Analysis'', vol. 23, n° 6, 1963, p. 121-123.
* Edmund L. Gettier, « Une croyance vraie et justifiée est-elle une connaissance ? », trad. fr. in [[w:Frédéric Nef|Julien Dutant]] &amp; [[w:Pascal Engel|Pascal Engel]] (dir.), ''Philosophie de la connaissance'', Paris, Vrin, 2005.
* Matthias Steup, ''An Introduction to Contemporary Epistemology'', Upper Saddle River, Prentice-Hall, 1996.

== Ressources ==

=== Texte de Gettier ===

* ({{en}}) [http://www.ditext.com/gettier/gettier.html &quot;Is Justified True Belief Knowledge?&quot;], texte anglais
* ({{fr}}) [http://julien.dutant.free.fr/ph316_2002/Gettier1963fr.doc ''Une croyance vraie et justifiée est-elle une connaissance ?''], traduction française par J. Dutant [http://julien.dutant.free.fr/ph316_2002/ sur son site]

=== Exposés ===

Le problème de Gettier a été exposé un nombre incalculable de fois. Citons :
* {{Sc|Steup}}, Matthias, ''An Introduction to Contemporary Epistemology'', 1996

===Articles ===
* « [http://www.iep.utm.edu/gettier/ Gettier Problems] », Stephen Hetherington, 2005
* {{pdf}} Julien Dutant, [http://philosophie-en-ligne.fr/klesis/Dutant-Klesis.pdf « Pourquoi le problème de Gettier est-il si important ? »], revue Klesis, n° 9, 2008

[[Catégorie:Théorie de la connaissance (livre)]]</text>
      <sha1>58dcyxclfxrg5ol9d9mbelra9vcmll1</sha1>
    </revision>
  </page>
  <page>
    <title>Philosophie/Théorie de la connaissance</title>
    <ns>0</ns>
    <id>55358</id>
    <revision>
      <id>769255</id>
      <parentid>411963</parentid>
      <timestamp>2026-07-01T03:51:57Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769255</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="914" sha1="hczm9yb580hq17it2ij87udf65k3lzj" xml:space="preserve">La '''théorie de la connaissance''', ou philosophie de la connaissance, parfois assimilée à l'épistémologie, est la partie de la philosophie qui étudie la nature, les origines, les contenus, les moyens et les limites de la connaissance.

Les différents chapitres sont indépendants les uns des autres, même s'ils se suivent avec une certaine logique. Des éléments sont répétés d'un chapitre à l'autre, mais présentés de manière différente.

=== Sommaire ===

# Qu'est-ce que la connaissance ?
## [[/Une définition traditionnelle|Une définition traditionnelle]] {{3/4}}
## [[Philosophie/Théorie de la connaissance/Le Problème de Gettier|Le Problème de Gettier]] {{3/4}}
# Nature de la justification
## Fondationalisme vs. cohérentisme
## Internalisme vs. externalisme
#Étendue de la connaissance
## Les Sources de la connaissance
## Le Scepticisme
[[Catégorie:Théorie de la connaissance]]</text>
      <sha1>hczm9yb580hq17it2ij87udf65k3lzj</sha1>
    </revision>
    <revision>
      <id>769260</id>
      <parentid>769255</parentid>
      <timestamp>2026-07-01T03:59:12Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769260</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="922" sha1="hznkrgrlty4morw97r21651gj2h4tpm" xml:space="preserve">La '''théorie de la connaissance''', ou philosophie de la connaissance, parfois assimilée à l'épistémologie, est la partie de la philosophie qui étudie la nature, les origines, les contenus, les moyens et les limites de la connaissance.

Les différents chapitres sont indépendants les uns des autres, même s'ils se suivent avec une certaine logique. Des éléments sont répétés d'un chapitre à l'autre, mais présentés de manière différente.

=== Sommaire ===

# Qu'est-ce que la connaissance ?
## [[/Une définition traditionnelle|Une définition traditionnelle]] {{3/4}}
## [[Philosophie/Théorie de la connaissance/Le Problème de Gettier|Le Problème de Gettier]] {{3/4}}
# Nature de la justification
## Fondationalisme vs. cohérentisme
## Internalisme vs. externalisme
#Étendue de la connaissance
## Les Sources de la connaissance
## Le Scepticisme
[[Catégorie:Théorie de la connaissance (livre)]]</text>
      <sha1>hznkrgrlty4morw97r21651gj2h4tpm</sha1>
    </revision>
    <revision>
      <id>769264</id>
      <parentid>769260</parentid>
      <timestamp>2026-07-01T04:00:48Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769264</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="924" sha1="bhk0z704m5dymfdvhu5a6kvvlj956dn" xml:space="preserve">La '''théorie de la connaissance''', ou philosophie de la connaissance, parfois assimilée à l'épistémologie, est la partie de la philosophie qui étudie la nature, les origines, les contenus, les moyens et les limites de la connaissance.

Les différents chapitres sont indépendants les uns des autres, même s'ils se suivent avec une certaine logique. Des éléments sont répétés d'un chapitre à l'autre, mais présentés de manière différente.

=== Sommaire ===

# Qu'est-ce que la connaissance ?
## [[/Une définition traditionnelle|Une définition traditionnelle]] {{3/4}}
## [[Philosophie/Théorie de la connaissance/Le Problème de Gettier|Le Problème de Gettier]] {{3/4}}
# Nature de la justification
## Fondationalisme vs. cohérentisme
## Internalisme vs. externalisme
#Étendue de la connaissance
## Les Sources de la connaissance
## Le Scepticisme
[[Catégorie:Théorie de la connaissance (livre)|*]]</text>
      <sha1>bhk0z704m5dymfdvhu5a6kvvlj956dn</sha1>
    </revision>
  </page>
  <page>
    <title>Philosophie/Théorie de la connaissance/Une définition traditionnelle</title>
    <ns>0</ns>
    <id>55369</id>
    <revision>
      <id>769262</id>
      <parentid>415064</parentid>
      <timestamp>2026-07-01T04:00:14Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769262</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16090" sha1="6v630y8c8bd2u5ppqs0nykfu0sm4tf2" xml:space="preserve">Dans ce chapitre, nous commencerons par distinguer différentes sortes de connaissance ; nous verrons ensuite que la connaissance propositionnelle est la forme de connaissance essentielle en théorie de la connaissance, et nous expliquerons chacun des points de la définition traditionnelle de cette sorte de connaissance.

== Trois formes de connaissance ==

Toutes les formes de connaissance ne font pas également l'objet de l'attention des philosophes. En suivant des auteurs comme {{sc|Steup}} et {{sc|Lehrer}}, nous distinguerons trois sortes de connaissance considérées comme les plus importantes, et nous verrons ensuite quelle sorte de connaissance est le plus souvent étudiée.

On peut les exprimer par ces trois phrases :
* Jean connaît le Président de la République.
* Jean sait faire du vélo.
* Jean sait que Paris est la capitale de la France.

La première phrase exprime une connaissance par « acquaintance » (ou directe), la deuxième un « savoir comment » (ou savoir faire) et la dernière une connaissance propositionnelle (« savoir que »).

&lt;u&gt;''Remarque''&lt;/u&gt; : vous pouvez voir que nous utilisons tout autant le verbe « connaître » que le verbe « savoir ». Nous ne ferons pas ici de distinctions entre ces mots, et nous nous concentrerons uniquement sur les sens du mot « connaissance » : lorsque nous utilisons « savoir » ou « connaître », c'est toujours cette notion que nous avons en vue.

* « Savoir comment » signifie avoir les compétences pour faire quelque chose : Jean sait faire du vélo, c'est une capacité, une aptitude.
* La connaissance par « acquaintance », c'est par exemple le fait de connaître une personne par une relation directe, et non par la description que l'on m'en fait.
* La connaissance propositionnelle est une forme d'information ({{sc|Lehrer}}) que je possède à propos de quelque chose.

Les philosophes s'intéressent principalement à cette troisième forme de connaissance, mais, avant de l'examiner, nous allons formuler quelques remarques sur ce qui distingue ou rapproche ces différents sens.

=== Connaissance directe et connaissance propositionnelle ===

La distinction entre ces deux formes de connaissance ne paraît pas toujours évidente. Quand on considère des réalités comme une ville et que l'on dit : « je connais Paris », on voit qu'il y a là deux sens possibles. D'un côté, je connais Paris car j'y vis ou l'ai visitée ; de l'autre, je sais que cette ville existe, où elle se trouve, etc. sans jamais y avoir été. Mais connaître Paris au premier sens, cela n'implique-t-il pas d'en avoir une connaissance propositionnelle ? Le fait d'avoir vu la tour Eiffel nous permet incontestablement de former des connaissances propositionnelles sur sa forme, ses couleurs, etc. Mais ces mêmes connaissances auraient pu nous être transmises par quelqu'un ou par un livre. En outre, je peux aussi apprendre dans un livre des connaissances que la connaissance directe ne me donne pas, comme la hauteur précise de la tour Eiffel. On voit donc que connaissance propositionnelle et connaissance directe ne s'impliquent pas toujours l'une l'autre.

Prenons encore un exemple pour mieux voir la grande différence qu'il y a entre ces deux formes de connaissance. Je peux savoir beaucoup de choses sur une personne, sans l'avoir jamais rencontrée. Je sais par exemple que Jules César est né en 100 avt. J.C., qu'il était Romain, mais je ne le connais pas personnellement. Je possède donc un grand nombre de propositions vraies sur César, mais sa connaissance directe est impossible. Dans le langage de tous les jours, nous y avons fait allusion, nous confondons parfois ces deux sens : quand nous disons que nous connaissons quelqu'un, cela peut vouloir dire que nous le fréquentons ou que nous en avons entendu parlé (par exemple, par quelqu'un d'autre ou dans des livres).

Dans le cadre de cette introduction, nous ne ferons pas une étude détaillée des relations entre ces deux genres de connaissance. Mais les éléments que nous avons exposés permettent déjà de voir toute l'importance de cette distinction. Par une connaissance directe, je vois que le soleil se meut mais pas la Terre ; par une connaissance propositionnelle, je sais que cette connaissance directe n'est en fait pas une connaissance, mais une erreur. De manière similaire, nous pensons souvent que la connaissance directe est suffisante pour nous former une idée correcte de la réalité. Notre exemple montre que ce n'est pas le cas, et c'est l'une des raisons qui expliquent pourquoi les philosophes vont surtout s'intéresser à la connaissance propositionnelle dans le cadre de la théorie de la connaissance.

=== Savoir comment et connaissance propositionnelle ===

Il est intéressant de noter qu'il existe des cas où un « savoir comment » n'implique pas une capacité. Par exemple, je suis pianiste et je joue telle sonate pour piano de Beethoven. Mon ami violoniste, qui est un musicien talentueux mais qui n'est pas pianiste, peut me donner des conseils sur la manière de jouer cette sonate. En tant que pianiste, je sais comment jouer cette sonate : j'ai les compétences techniques pour le faire ; mon ami violoniste sais aussi comment jouer cette sonate, mais il n'a pas le même « savoir comment » que moi : il n'est pas pianiste, mais il a des connaissances propositionnelles sur la manière d'interpréter cette sonate.

Nous avons donc là deux façons de « savoir comment », et elle ne s'impliquent pas l'une autre. Un enfant qui apprend à marcher n'a aucune connaissance sur les processus physiologiques qui rendent possibles la marche.


Ces quelques remarques montrent que les différents sens du mot « connaissance » ne sont pas nécessairement exclusifs ou juxtaposés les uns à côté des autres ; certaines connaissances en impliquent d'autres, mais ce n'est pas toujours le cas. Il faut donc être très attentif quand on parle des différentes sortes de connaissance, car on peut facilement passer à côté d'une forme de connaissance ou la confondre avec une autre.

== La connaissance propositionnelle ==

Nous allons à présent examiner une définition de la connaissance que l'on qualifie souvent de traditionnelle et qui est un lieu commun en théorie de la connaissance&lt;ref&gt;{{sc|BonJour}}, p. 4.&lt;/ref&gt;. 

=== Une définition traditionnelle ===

Une personne sait que P si, et seulement si :
# elle croit que P est vrai ;
# P est vrai ;
# elle est justifiée à croire que P est vrai.

Chacun de ces points est une condition nécessaire pour qu'il y ait connaissance, c'est-à-dire que si l'une des conditions est absente, il n'y a pas de connaissance. C'est ce que nous allons montrer dans cette partie.

Ces conditions font toutes l'objet de discussions à divers degrés, mais c'est surtout la justification qui pose des problèmes particulièrement difficiles à résoudre. Malgré ces discussions, cette définition reste pour la plupart des auteurs une définition « approximativement correcte » ({{sc|BonJour}}) de la connaissance propositionnelle.

=== Croyance ===

Pour savoir que les arbres dans la cour devant chez moi sont des peupliers, je dois tout d'abord avoir la croyance que ces arbres sont des peupliers. En effet, affirmer à la fois « Je ne crois pas que ces arbres sont des peupliers » et « Je sais que ces arbres sont des peupliers » apparaît contradictoire. Ce point ne fait guère l'objet de polémique, même s'il existe des tentatives pour le mettre en défaut.

La croyance est ce que l'on appelle une ''attitude propositionnelle'', c'est-à-dire une relation entre un sujet et une proposition. Il existe toutes sortes d'attitudes propositionnelles en plus des croyances : je peux par exemple considérer une proposition (« la Terre a des ailes »), sans y croire. Le sujet pense cette proposition (P) : il pense que P, sans croire que P soit vraie ou fausse. On peut également dire que P (je dis que la Terre a des ailes) ou désirer que P.

Or, pour une croyance, on dira qu'une personne croit que P ''est vraie''. Pour distinguer la croyance des autres attitudes propositionnelles nous dirons donc que ''la croyance consiste à tenir quelque chose pour vrai.'' Ainsi, savoir quelque chose, c'est le tenir pour vrai.

Mais nous pouvons tenir quelque chose pour plus ou moins vrai. Le degré d'une croyance est donc un problème à considérer, en distinguant par exemple opinion, avis, sentiment que, etc. Pour {{sc|BonJour}}, il s'agit ici de tenir pour vraie une proposition avec une certaine assurance, c'est-à-dire qu'il faut que cette croyance soit plus qu'une vague opinion, même si une certitude absolue n'est sans doute pas requise.

Mais nous ne proposerons pas ici de discussion détaillée de ces points : il nous suffit pour le moment de voir que l'on ne peut connaître sans croire.

=== Vérité ===
{{Loupe|Vérité}}
Comme pour la notion de croyance, nous n'allons pas nous engager dans une discussion détaillée des théories sur la nature de la vérité : elles sont nombreuses et souvent difficiles. Mais dans le cadre d'une introduction, nous allons le voir, ce ne sera pas vraiment un problème pour expliquer la deuxième condition de notre définition.

Reprenons notre exemple : je crois que les arbres dans ma cour sont des peupliers ; or, il se trouve que ces arbres ne sont pas des peupliers. Nous voyons bien, dans ce cas, que je ne sais pas que ces arbres sont des peupliers : ma croyance est fausse car elle ne correspond pas à la réalité, et une croyance fausse n'est pas une connaissance.
* Je crois que P est vrai ;
* P est faux ;
* « P est vrai » n'est pas une connaissance.
* Ma croyance que P est vrai n'est pas une connaissance.

Cet exemple anodin suppose que ma croyance est vraie quand elle ''correspond'' à un fait ou quand elle décrit une certaine réalité telle qu'elle est, et qu'elle est fausse dans le cas contraire. L'exemple suppose donc une certaine idée  de la nature de la vérité(la ''correspondance''). Bien que cette idée soit problématique, notre exemple est suffisant pour montrer que je sais quelque chose si, et seulement si, ma croyance est vraie, quelle que soit l'idée que l'on se fait de la vérité ; en effet, une croyance fausse n'est pas une connaissance.

=== Justification===
{{Loupe|Le Problème de Gettier}}

Croyance et vérité, nos deux premières conditions, ne suffisent pas à produire la connaissance. Nous emprunterons à Bertrand Russell quelques exemples pour le montrer.

'''Premier exemple :'''
: « Si un journal, par une anticipation intelligente, annonce le résultat dune bataille avant qu'ait été reçu aucun télégramme donnant le résultat, il peut par chance annoncer ce qui se trouve ensuite être le résultat juste, et produire une croyance chez quelques uns de ses lecteurs les moins expérimentés. Mais bien que leur croyance soit vraie, on ne peut pas dire qu'ils aient une connaissance. »

'''Deuxième exemple :'''
:« Si je sais que tous les Grecs sont des hommes et que Socrate était un homme, et que j'en infère que Socrate était un Grec, on ne peut pas dire que je sache que Socrate était un Grec, parce que, bien que mes prémisses et ma conclusion soient vraies, la conclusion ne suit pas des prémisses. »

On le voit, la manière dont sont formées les croyances vraies, dans ces deux exemples, est inappropriée. Toutes les croyances vraies ne sont donc pas des connaissances, et s'il en est ainsi c'est parce que la ''justification'' de certaines croyances vraies n'est pas appropriée. De ce fait, toutes les connaissances seront des croyances vraies ''justifiées'' d'une certaine façon. C'est notre troisième et dernière condition : je dois avoir une croyance justifiée de manière appropriée pour que cette croyance soit une connaissance.

Si j'ai une croyance et que cette croyance est vraie par ''chance'' ou ''hasard'', comme dans nos deux exemples, ce n'est pas une connaissance : ainsi, un raisonnement faux qui conduit à une conclusion vraie, un concours de circonstance, mais aussi une conviction arbitraire, une supposition faite au hasard, un pressentiment, etc. ne sont pas des justifications appropriées. La question est de savoir ce qu'est une justification appropriée, et plusieurs réponses très discutées ont été apportées à cette question. Nous aurons l'occasion d'y revenir dans le prochain chapitre, mais nous pouvons dès à présent tenter d'éclairer un peu cette notion.

Selon {{sc|BonJour}}, la justification dont nous avons besoin est d'ordre épistémique, c'est-à-dire relative à la connaissance. Ce que nous proposons d'examiner ici, c'est comment une justification épistémique se distingue d'autres genres de justifications. Nous pouvons justifier une croyance par des valeurs morales, par des raisons théologiques, mais ce ne sont apparemment pas là des justifications épistémiques, c'est-à-dire que ce ne sont pas des justifications appropriées pour connaître.

{{sc|BonJour}} propose l'exemple suivant pour bien saisir la différence qu'il peut y avoir entre ces formes de justifications : un ami qui m'a aidé par le passé lorsque j'étais dans une situation difficile est accusé d'un crime horrible. Tout le monde le pense coupable. Supposons que je ne dispose personnellement d'aucun indice et que mon ami me connaisse assez pour savoir qu'un mensonge de sa part ne passerait pas inaperçu. Je suis justifié dans ce cas à le croire innocent, et c'est même pour moi une obligation ''morale''. Pourtant, je ne sais pas s'il est ou non innocent, je suis seulement justifié ''moralement'' à le croire : mes raisons peuvent être très bonnes, elles ne sont pas épistémiques.

Ce qui distingue dès lors une justification épistémique d'une justification morale, c'est le ''souci de la vérité''. Les justifications de croire mon ami innocent ne sont pas une bonne manière de parvenir à la vérité : si je suis dans le vrai à son sujet, ce n'est pas pour de bonnes raisons, mais par hasard. La justification épistémique est donc une attitude particulière à l'égard de certaines de nos croyances : nous voulons qu'elles décrivent correctement la réalité. Dès lors, la fonction de cette sorte de justification est d'être un instrument pour attendre notre but, qui est la vérité.

Pour terminer sur ces distinctions, on peut tenir le même raisonnement avec des croyances religieuses : une croyance religieuse fondée sur des textes et des traditions, qui se trouverait vraie, n'est pas une connaissance, parce qu'elle n'est pas épistémologiquement justifiée.

== Pour finir ==

Il est important de rappeler qu'il ne s'agit ici que d'une introduction : chaque point a été formulé de manière aussi simple et courte que possible, et nous n'avons fait dans ce but que reprendre les exposés qui se trouvent dans les livres donnés en bibliographie. Si cette introduction se veut simple, il ne s'agit pas pour autant d'une simplification : les termes et arguments employés sont aussi ''précis'' que possible pour une introduction, mais ils sont ''insuffisants'' pour en discuter dans le détail.

== Bibliographie ==

Tous les livres de cette section ont été utilisés pour la rédaction de ce chapitre. Ce sont majoritairement des ouvrages anglophones, mais il n'est pas nécessaire d'avoir une parfaite connaissance de l'anglais pour les lire et les bien comprendre : il n'y a pas de jargon, le vocabulaire est assez restreint et le style est avant tout argumentatif.

* {{sc|BonJour}}, Laurence, ''The Structure of Empirical Knowledge'', 1983
* {{Sc|Chisholm}}, Roderick, ''Theory of Knowledge'', 3rd edition, 1989
* {{Sc|Lehrer}}, Keith, ''Theory of Knowledge'', 2nd ed., 2000
* {{Sc|Lemos}}, Noah, ''An Introduction to the Theory of Knowledge'', 2007
* {{Sc|Steup}}, Matthias, ''An Introduction to Contemporary Epistemology'', 1996
* {{Sc|Russell}}, Bertrand, ''Les Problèmes de la philosophie'', 1912

==Références==
&lt;references/&gt;

Catégorie:Théorie de la connaissance (livre)</text>
      <sha1>6v630y8c8bd2u5ppqs0nykfu0sm4tf2</sha1>
    </revision>
    <revision>
      <id>769263</id>
      <parentid>769262</parentid>
      <timestamp>2026-07-01T04:00:31Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769263</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16094" sha1="qbjtamk7skc7dz9890kt444v4nqxz48" xml:space="preserve">Dans ce chapitre, nous commencerons par distinguer différentes sortes de connaissance ; nous verrons ensuite que la connaissance propositionnelle est la forme de connaissance essentielle en théorie de la connaissance, et nous expliquerons chacun des points de la définition traditionnelle de cette sorte de connaissance.

== Trois formes de connaissance ==

Toutes les formes de connaissance ne font pas également l'objet de l'attention des philosophes. En suivant des auteurs comme {{sc|Steup}} et {{sc|Lehrer}}, nous distinguerons trois sortes de connaissance considérées comme les plus importantes, et nous verrons ensuite quelle sorte de connaissance est le plus souvent étudiée.

On peut les exprimer par ces trois phrases :
* Jean connaît le Président de la République.
* Jean sait faire du vélo.
* Jean sait que Paris est la capitale de la France.

La première phrase exprime une connaissance par « acquaintance » (ou directe), la deuxième un « savoir comment » (ou savoir faire) et la dernière une connaissance propositionnelle (« savoir que »).

&lt;u&gt;''Remarque''&lt;/u&gt; : vous pouvez voir que nous utilisons tout autant le verbe « connaître » que le verbe « savoir ». Nous ne ferons pas ici de distinctions entre ces mots, et nous nous concentrerons uniquement sur les sens du mot « connaissance » : lorsque nous utilisons « savoir » ou « connaître », c'est toujours cette notion que nous avons en vue.

* « Savoir comment » signifie avoir les compétences pour faire quelque chose : Jean sait faire du vélo, c'est une capacité, une aptitude.
* La connaissance par « acquaintance », c'est par exemple le fait de connaître une personne par une relation directe, et non par la description que l'on m'en fait.
* La connaissance propositionnelle est une forme d'information ({{sc|Lehrer}}) que je possède à propos de quelque chose.

Les philosophes s'intéressent principalement à cette troisième forme de connaissance, mais, avant de l'examiner, nous allons formuler quelques remarques sur ce qui distingue ou rapproche ces différents sens.

=== Connaissance directe et connaissance propositionnelle ===

La distinction entre ces deux formes de connaissance ne paraît pas toujours évidente. Quand on considère des réalités comme une ville et que l'on dit : « je connais Paris », on voit qu'il y a là deux sens possibles. D'un côté, je connais Paris car j'y vis ou l'ai visitée ; de l'autre, je sais que cette ville existe, où elle se trouve, etc. sans jamais y avoir été. Mais connaître Paris au premier sens, cela n'implique-t-il pas d'en avoir une connaissance propositionnelle ? Le fait d'avoir vu la tour Eiffel nous permet incontestablement de former des connaissances propositionnelles sur sa forme, ses couleurs, etc. Mais ces mêmes connaissances auraient pu nous être transmises par quelqu'un ou par un livre. En outre, je peux aussi apprendre dans un livre des connaissances que la connaissance directe ne me donne pas, comme la hauteur précise de la tour Eiffel. On voit donc que connaissance propositionnelle et connaissance directe ne s'impliquent pas toujours l'une l'autre.

Prenons encore un exemple pour mieux voir la grande différence qu'il y a entre ces deux formes de connaissance. Je peux savoir beaucoup de choses sur une personne, sans l'avoir jamais rencontrée. Je sais par exemple que Jules César est né en 100 avt. J.C., qu'il était Romain, mais je ne le connais pas personnellement. Je possède donc un grand nombre de propositions vraies sur César, mais sa connaissance directe est impossible. Dans le langage de tous les jours, nous y avons fait allusion, nous confondons parfois ces deux sens : quand nous disons que nous connaissons quelqu'un, cela peut vouloir dire que nous le fréquentons ou que nous en avons entendu parlé (par exemple, par quelqu'un d'autre ou dans des livres).

Dans le cadre de cette introduction, nous ne ferons pas une étude détaillée des relations entre ces deux genres de connaissance. Mais les éléments que nous avons exposés permettent déjà de voir toute l'importance de cette distinction. Par une connaissance directe, je vois que le soleil se meut mais pas la Terre ; par une connaissance propositionnelle, je sais que cette connaissance directe n'est en fait pas une connaissance, mais une erreur. De manière similaire, nous pensons souvent que la connaissance directe est suffisante pour nous former une idée correcte de la réalité. Notre exemple montre que ce n'est pas le cas, et c'est l'une des raisons qui expliquent pourquoi les philosophes vont surtout s'intéresser à la connaissance propositionnelle dans le cadre de la théorie de la connaissance.

=== Savoir comment et connaissance propositionnelle ===

Il est intéressant de noter qu'il existe des cas où un « savoir comment » n'implique pas une capacité. Par exemple, je suis pianiste et je joue telle sonate pour piano de Beethoven. Mon ami violoniste, qui est un musicien talentueux mais qui n'est pas pianiste, peut me donner des conseils sur la manière de jouer cette sonate. En tant que pianiste, je sais comment jouer cette sonate : j'ai les compétences techniques pour le faire ; mon ami violoniste sais aussi comment jouer cette sonate, mais il n'a pas le même « savoir comment » que moi : il n'est pas pianiste, mais il a des connaissances propositionnelles sur la manière d'interpréter cette sonate.

Nous avons donc là deux façons de « savoir comment », et elle ne s'impliquent pas l'une autre. Un enfant qui apprend à marcher n'a aucune connaissance sur les processus physiologiques qui rendent possibles la marche.


Ces quelques remarques montrent que les différents sens du mot « connaissance » ne sont pas nécessairement exclusifs ou juxtaposés les uns à côté des autres ; certaines connaissances en impliquent d'autres, mais ce n'est pas toujours le cas. Il faut donc être très attentif quand on parle des différentes sortes de connaissance, car on peut facilement passer à côté d'une forme de connaissance ou la confondre avec une autre.

== La connaissance propositionnelle ==

Nous allons à présent examiner une définition de la connaissance que l'on qualifie souvent de traditionnelle et qui est un lieu commun en théorie de la connaissance&lt;ref&gt;{{sc|BonJour}}, p. 4.&lt;/ref&gt;. 

=== Une définition traditionnelle ===

Une personne sait que P si, et seulement si :
# elle croit que P est vrai ;
# P est vrai ;
# elle est justifiée à croire que P est vrai.

Chacun de ces points est une condition nécessaire pour qu'il y ait connaissance, c'est-à-dire que si l'une des conditions est absente, il n'y a pas de connaissance. C'est ce que nous allons montrer dans cette partie.

Ces conditions font toutes l'objet de discussions à divers degrés, mais c'est surtout la justification qui pose des problèmes particulièrement difficiles à résoudre. Malgré ces discussions, cette définition reste pour la plupart des auteurs une définition « approximativement correcte » ({{sc|BonJour}}) de la connaissance propositionnelle.

=== Croyance ===

Pour savoir que les arbres dans la cour devant chez moi sont des peupliers, je dois tout d'abord avoir la croyance que ces arbres sont des peupliers. En effet, affirmer à la fois « Je ne crois pas que ces arbres sont des peupliers » et « Je sais que ces arbres sont des peupliers » apparaît contradictoire. Ce point ne fait guère l'objet de polémique, même s'il existe des tentatives pour le mettre en défaut.

La croyance est ce que l'on appelle une ''attitude propositionnelle'', c'est-à-dire une relation entre un sujet et une proposition. Il existe toutes sortes d'attitudes propositionnelles en plus des croyances : je peux par exemple considérer une proposition (« la Terre a des ailes »), sans y croire. Le sujet pense cette proposition (P) : il pense que P, sans croire que P soit vraie ou fausse. On peut également dire que P (je dis que la Terre a des ailes) ou désirer que P.

Or, pour une croyance, on dira qu'une personne croit que P ''est vraie''. Pour distinguer la croyance des autres attitudes propositionnelles nous dirons donc que ''la croyance consiste à tenir quelque chose pour vrai.'' Ainsi, savoir quelque chose, c'est le tenir pour vrai.

Mais nous pouvons tenir quelque chose pour plus ou moins vrai. Le degré d'une croyance est donc un problème à considérer, en distinguant par exemple opinion, avis, sentiment que, etc. Pour {{sc|BonJour}}, il s'agit ici de tenir pour vraie une proposition avec une certaine assurance, c'est-à-dire qu'il faut que cette croyance soit plus qu'une vague opinion, même si une certitude absolue n'est sans doute pas requise.

Mais nous ne proposerons pas ici de discussion détaillée de ces points : il nous suffit pour le moment de voir que l'on ne peut connaître sans croire.

=== Vérité ===
{{Loupe|Vérité}}
Comme pour la notion de croyance, nous n'allons pas nous engager dans une discussion détaillée des théories sur la nature de la vérité : elles sont nombreuses et souvent difficiles. Mais dans le cadre d'une introduction, nous allons le voir, ce ne sera pas vraiment un problème pour expliquer la deuxième condition de notre définition.

Reprenons notre exemple : je crois que les arbres dans ma cour sont des peupliers ; or, il se trouve que ces arbres ne sont pas des peupliers. Nous voyons bien, dans ce cas, que je ne sais pas que ces arbres sont des peupliers : ma croyance est fausse car elle ne correspond pas à la réalité, et une croyance fausse n'est pas une connaissance.
* Je crois que P est vrai ;
* P est faux ;
* « P est vrai » n'est pas une connaissance.
* Ma croyance que P est vrai n'est pas une connaissance.

Cet exemple anodin suppose que ma croyance est vraie quand elle ''correspond'' à un fait ou quand elle décrit une certaine réalité telle qu'elle est, et qu'elle est fausse dans le cas contraire. L'exemple suppose donc une certaine idée  de la nature de la vérité(la ''correspondance''). Bien que cette idée soit problématique, notre exemple est suffisant pour montrer que je sais quelque chose si, et seulement si, ma croyance est vraie, quelle que soit l'idée que l'on se fait de la vérité ; en effet, une croyance fausse n'est pas une connaissance.

=== Justification===
{{Loupe|Le Problème de Gettier}}

Croyance et vérité, nos deux premières conditions, ne suffisent pas à produire la connaissance. Nous emprunterons à Bertrand Russell quelques exemples pour le montrer.

'''Premier exemple :'''
: « Si un journal, par une anticipation intelligente, annonce le résultat dune bataille avant qu'ait été reçu aucun télégramme donnant le résultat, il peut par chance annoncer ce qui se trouve ensuite être le résultat juste, et produire une croyance chez quelques uns de ses lecteurs les moins expérimentés. Mais bien que leur croyance soit vraie, on ne peut pas dire qu'ils aient une connaissance. »

'''Deuxième exemple :'''
:« Si je sais que tous les Grecs sont des hommes et que Socrate était un homme, et que j'en infère que Socrate était un Grec, on ne peut pas dire que je sache que Socrate était un Grec, parce que, bien que mes prémisses et ma conclusion soient vraies, la conclusion ne suit pas des prémisses. »

On le voit, la manière dont sont formées les croyances vraies, dans ces deux exemples, est inappropriée. Toutes les croyances vraies ne sont donc pas des connaissances, et s'il en est ainsi c'est parce que la ''justification'' de certaines croyances vraies n'est pas appropriée. De ce fait, toutes les connaissances seront des croyances vraies ''justifiées'' d'une certaine façon. C'est notre troisième et dernière condition : je dois avoir une croyance justifiée de manière appropriée pour que cette croyance soit une connaissance.

Si j'ai une croyance et que cette croyance est vraie par ''chance'' ou ''hasard'', comme dans nos deux exemples, ce n'est pas une connaissance : ainsi, un raisonnement faux qui conduit à une conclusion vraie, un concours de circonstance, mais aussi une conviction arbitraire, une supposition faite au hasard, un pressentiment, etc. ne sont pas des justifications appropriées. La question est de savoir ce qu'est une justification appropriée, et plusieurs réponses très discutées ont été apportées à cette question. Nous aurons l'occasion d'y revenir dans le prochain chapitre, mais nous pouvons dès à présent tenter d'éclairer un peu cette notion.

Selon {{sc|BonJour}}, la justification dont nous avons besoin est d'ordre épistémique, c'est-à-dire relative à la connaissance. Ce que nous proposons d'examiner ici, c'est comment une justification épistémique se distingue d'autres genres de justifications. Nous pouvons justifier une croyance par des valeurs morales, par des raisons théologiques, mais ce ne sont apparemment pas là des justifications épistémiques, c'est-à-dire que ce ne sont pas des justifications appropriées pour connaître.

{{sc|BonJour}} propose l'exemple suivant pour bien saisir la différence qu'il peut y avoir entre ces formes de justifications : un ami qui m'a aidé par le passé lorsque j'étais dans une situation difficile est accusé d'un crime horrible. Tout le monde le pense coupable. Supposons que je ne dispose personnellement d'aucun indice et que mon ami me connaisse assez pour savoir qu'un mensonge de sa part ne passerait pas inaperçu. Je suis justifié dans ce cas à le croire innocent, et c'est même pour moi une obligation ''morale''. Pourtant, je ne sais pas s'il est ou non innocent, je suis seulement justifié ''moralement'' à le croire : mes raisons peuvent être très bonnes, elles ne sont pas épistémiques.

Ce qui distingue dès lors une justification épistémique d'une justification morale, c'est le ''souci de la vérité''. Les justifications de croire mon ami innocent ne sont pas une bonne manière de parvenir à la vérité : si je suis dans le vrai à son sujet, ce n'est pas pour de bonnes raisons, mais par hasard. La justification épistémique est donc une attitude particulière à l'égard de certaines de nos croyances : nous voulons qu'elles décrivent correctement la réalité. Dès lors, la fonction de cette sorte de justification est d'être un instrument pour attendre notre but, qui est la vérité.

Pour terminer sur ces distinctions, on peut tenir le même raisonnement avec des croyances religieuses : une croyance religieuse fondée sur des textes et des traditions, qui se trouverait vraie, n'est pas une connaissance, parce qu'elle n'est pas épistémologiquement justifiée.

== Pour finir ==

Il est important de rappeler qu'il ne s'agit ici que d'une introduction : chaque point a été formulé de manière aussi simple et courte que possible, et nous n'avons fait dans ce but que reprendre les exposés qui se trouvent dans les livres donnés en bibliographie. Si cette introduction se veut simple, il ne s'agit pas pour autant d'une simplification : les termes et arguments employés sont aussi ''précis'' que possible pour une introduction, mais ils sont ''insuffisants'' pour en discuter dans le détail.

== Bibliographie ==

Tous les livres de cette section ont été utilisés pour la rédaction de ce chapitre. Ce sont majoritairement des ouvrages anglophones, mais il n'est pas nécessaire d'avoir une parfaite connaissance de l'anglais pour les lire et les bien comprendre : il n'y a pas de jargon, le vocabulaire est assez restreint et le style est avant tout argumentatif.

* {{sc|BonJour}}, Laurence, ''The Structure of Empirical Knowledge'', 1983
* {{Sc|Chisholm}}, Roderick, ''Theory of Knowledge'', 3rd edition, 1989
* {{Sc|Lehrer}}, Keith, ''Theory of Knowledge'', 2nd ed., 2000
* {{Sc|Lemos}}, Noah, ''An Introduction to the Theory of Knowledge'', 2007
* {{Sc|Steup}}, Matthias, ''An Introduction to Contemporary Epistemology'', 1996
* {{Sc|Russell}}, Bertrand, ''Les Problèmes de la philosophie'', 1912

==Références==
&lt;references/&gt;

[[Catégorie:Théorie de la connaissance (livre)]]</text>
      <sha1>qbjtamk7skc7dz9890kt444v4nqxz48</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Commentaire philosophique (livre)</title>
    <ns>14</ns>
    <id>66628</id>
    <revision>
      <id>769252</id>
      <parentid>765037</parentid>
      <timestamp>2026-07-01T03:38:11Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769252</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="171" sha1="kmbvgq6bdbf2t6fa8a5qf2sqd2wcuxd" xml:space="preserve">Analyses de textes philosophiques avec des exercices.

[[Catégorie:Livres par titre]]
[[Catégorie:Histoire de la philosophie]]
[[Catégorie:Commentaire philosophique|*]]</text>
      <sha1>kmbvgq6bdbf2t6fa8a5qf2sqd2wcuxd</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Précis d'épistémologie (livre)</title>
    <ns>14</ns>
    <id>68948</id>
    <revision>
      <id>769266</id>
      <parentid>765027</parentid>
      <timestamp>2026-07-01T04:02:31Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769266</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="116" sha1="cljzsezp59vrrv86p4r8ar81sc6uuig" xml:space="preserve">[[Catégorie:Livres par titre]]
[[Catégorie:épistémologie ]]
[[Catégorie:Classe 1 - Philosophie et psychologie]]</text>
      <sha1>cljzsezp59vrrv86p4r8ar81sc6uuig</sha1>
    </revision>
  </page>
  <page>
    <title>Python pour le calcul scientifique/Découverte de Python et de Jupyter</title>
    <ns>0</ns>
    <id>72864</id>
    <revision>
      <id>769272</id>
      <parentid>768629</parentid>
      <timestamp>2026-07-01T06:58:08Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Vocabulaire */ exemple</comment>
      <origin>769272</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24226" sha1="aifdh388aiu9wzcbxtedptoq848z0sx" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Ci-dessous, nous verrons la méthode &lt;code&gt;.append()&lt;/code&gt; attachée aux objets de type « liste » (voir la section ''[[##Listes_et_n-uplets|#Listes_et_n-uplets]]'' ci-dessous). 
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>aifdh388aiu9wzcbxtedptoq848z0sx</sha1>
    </revision>
    <revision>
      <id>769273</id>
      <parentid>769272</parentid>
      <timestamp>2026-07-01T06:58:26Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Vocabulaire */ typo</comment>
      <origin>769273</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24224" sha1="4k4405zxn2v5dlut0ovwx92bsbb3ovt" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Ci-dessous, nous verrons la méthode &lt;code&gt;.append()&lt;/code&gt; attachée aux objets de type « liste » (voir la section ''[[#Listes_et_n-uplets|Listes_et_n-uplets]]'' ci-dessous). 
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>4k4405zxn2v5dlut0ovwx92bsbb3ovt</sha1>
    </revision>
    <revision>
      <id>769274</id>
      <parentid>769273</parentid>
      <timestamp>2026-07-01T06:58:55Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Vocabulaire */</comment>
      <origin>769274</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24223" sha1="s842l43848f8m9hrrrdzh5sqdi3tmka" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons la méthode &lt;code&gt;.append()&lt;/code&gt; attachée aux objets de type « liste » (voir la section ''[[#Listes_et_n-uplets|Listes_et_n-uplets]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>s842l43848f8m9hrrrdzh5sqdi3tmka</sha1>
    </revision>
    <revision>
      <id>769275</id>
      <parentid>769274</parentid>
      <timestamp>2026-07-01T07:00:13Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Vocabulaire */ + d'exemples</comment>
      <origin>769275</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24273" sha1="alsutj79jb65gvxtkz1wbb8pzp15jrc" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes_et_n-uplets|Listes_et_n-uplets]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>alsutj79jb65gvxtkz1wbb8pzp15jrc</sha1>
    </revision>
    <revision>
      <id>769277</id>
      <parentid>769275</parentid>
      <timestamp>2026-07-01T07:05:39Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Listes et n-uplets */ sectionnage</comment>
      <origin>769277</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24332" sha1="nwv2gj70ajobmpctkqrg0wa8ylav063" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes_et_n-uplets|Listes_et_n-uplets]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>nwv2gj70ajobmpctkqrg0wa8ylav063</sha1>
    </revision>
    <revision>
      <id>769278</id>
      <parentid>769277</parentid>
      <timestamp>2026-07-01T07:06:16Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Vocabulaire */ lien plus précis</comment>
      <origin>769278</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24308" sha1="8i3845k6bz9gf7pdq39h16wt7hafgn8" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>8i3845k6bz9gf7pdq39h16wt7hafgn8</sha1>
    </revision>
    <revision>
      <id>769281</id>
      <parentid>769278</parentid>
      <timestamp>2026-07-01T07:15:58Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Listes */ .sort</comment>
      <origin>769281</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24913" sha1="exj8y2ie3ds0zsktva0r0j6ztcwq0wm" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;[…]&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>exj8y2ie3ds0zsktva0r0j6ztcwq0wm</sha1>
    </revision>
    <revision>
      <id>769283</id>
      <parentid>769281</parentid>
      <timestamp>2026-07-01T07:17:42Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Itérable */ corr.</comment>
      <origin>769283</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="24913" sha1="r0raoj8ze4cth2rzp2pjwt12c0gpjkz" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>r0raoj8ze4cth2rzp2pjwt12c0gpjkz</sha1>
    </revision>
    <revision>
      <id>769284</id>
      <parentid>769283</parentid>
      <timestamp>2026-07-01T07:19:12Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Listes */ list()</comment>
      <origin>769284</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25096" sha1="7i20xov8wiy9vkgektffjtj4b2pl861" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

On peut construire une liste à partir de n'importe quel objet itérable avec la commande &lt;code&gt;list(''itérable'')&lt;/code&gt; (voir la section ''[[#Itérable|Itérable]]'' ci-dessous).

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot; &quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# 1 2 3 A B C a b c
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>7i20xov8wiy9vkgektffjtj4b2pl861</sha1>
    </revision>
    <revision>
      <id>769286</id>
      <parentid>769284</parentid>
      <timestamp>2026-07-01T07:26:12Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Itérable */ exemple restructuré</comment>
      <origin>769286</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25165" sha1="pvp6fesaaxc1oxoxpq2ylain3njocjn" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

On peut construire une liste à partir de n'importe quel objet itérable avec la commande &lt;code&gt;list(''itérable'')&lt;/code&gt; (voir la section ''[[#Itérable|Itérable]]'' ci-dessous).

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot;, &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
# A, B, C, 
print(&quot;&quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# a, b, c, 
print(&quot;&quot;)
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>pvp6fesaaxc1oxoxpq2ylain3njocjn</sha1>
    </revision>
    <revision>
      <id>769287</id>
      <parentid>769286</parentid>
      <timestamp>2026-07-01T07:32:33Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Itérable */ sorted</comment>
      <origin>769287</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25937" sha1="g2le08lvt3l9srygzc59t1265jsotg9" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

On peut construire une liste à partir de n'importe quel objet itérable avec la commande &lt;code&gt;list(''itérable'')&lt;/code&gt; (voir la section ''[[#Itérable|Itérable]]'' ci-dessous).

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot;, &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
# A, B, C, 
print(&quot;&quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# a, b, c, 
print(&quot;&quot;)
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;sorted()&lt;/code&gt; trie les itérables par ordre croissant, à condition que les éléments soient comparables (typiquement tous des nombres ou bien tous des chaînes de caractères). Le paramètre &lt;code&gt;reverse=True&lt;/code&gt; permet de trier par ordre décroissant. Notez que le résultat est forcément une liste.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
A = sorted(A, reverse = True)
print(type(A), A)
# &lt;class 'list'&gt; [3, 2, 1]
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
B = sorted(B, reverse = True)
print(type(B), B)
# &lt;class 'list'&gt; ['C', 'B', 'A']
C = &quot;123&quot;
C = sorted(C, reverse = True)
print(type(C), C)
# &lt;class 'list'&gt; ['3', '2', '1']
D = dict(a = 1, b = 2, c = 3)
D = sorted(D, reverse = True)
print(type(D), D)
# &lt;class 'list'&gt; ['c', 'b', 'a']
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>g2le08lvt3l9srygzc59t1265jsotg9</sha1>
    </revision>
    <revision>
      <id>769289</id>
      <parentid>769287</parentid>
      <timestamp>2026-07-01T07:56:22Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Itérable */ notion d'itérateur</comment>
      <origin>769289</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="27173" sha1="k6vogrxr2ocfhfksvg23hfgzpfoek3a" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

On peut construire une liste à partir de n'importe quel objet itérable avec la commande &lt;code&gt;list(''itérable'')&lt;/code&gt; (voir la section ''[[#Itérable|Itérable]]'' ci-dessous).

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__cal__&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot;, &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
# A, B, C, 
print(&quot;&quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# a, b, c, 
print(&quot;&quot;)
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;sorted()&lt;/code&gt; trie les itérables par ordre croissant, à condition que les éléments soient comparables (typiquement tous des nombres ou bien tous des chaînes de caractères). Le paramètre &lt;code&gt;reverse=True&lt;/code&gt; permet de trier par ordre décroissant. Notez que le résultat est forcément une liste.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
A = sorted(A, reverse = True)
print(type(A), A)
# &lt;class 'list'&gt; [3, 2, 1]
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
B = sorted(B, reverse = True)
print(type(B), B)
# &lt;class 'list'&gt; ['C', 'B', 'A']
C = &quot;123&quot;
C = sorted(C, reverse = True)
print(type(C), C)
# &lt;class 'list'&gt; ['3', '2', '1']
D = dict(a = 1, b = 2, c = 3)
D = sorted(D, reverse = True)
print(type(D), D)
# &lt;class 'list'&gt; ['c', 'b', 'a']
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

{{note |Il ne faut pas confondre itérable et itérateur ''({{lang|en|iterator}})''. Un itérateur représente un flux de données, et est typiquement construit lors de l'utilisation d'une structure &lt;code&gt;for&lt;/code&gt;. On peut construire directement un itérateur avec la fonction &lt;code&gt;iter()&lt;/code&gt;, ou bien avec la fonction &lt;code&gt;reversed()&lt;/code&gt; auquel cas le flux de données est inversé. Les itérateurs possèdent la méthode &lt;code&gt;__next__()&lt;/code&gt; qui renvoie l'élément suivant (et le premier élément au premier appel).

On peut transformer un itérateur en liste ou en n-uplet, mais cela interrompt alors le flux de données (on ne peut plus utiliser &lt;code&gt;.__next__()&lt;/code&gt;).

La manipulation directe d'itérateurs n'est pas très utile, mais connaître cette notion permet de mieux comprendre le fonctionnement de Python.}}
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3, 4, 5]
A = iter(A)
print(A)
# &lt;list_iterator object at 0x00000204181AB3A0&gt;
print(A.__next__())
# 1
print(A.__next__())
# 2
print(list(A))
# [3, 4, 5]

B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;, &quot;E&quot;)
B = reversed(B)
print(B)
# &lt;reversed object at 0x0000020417A7E9B0&gt;
print(B.__next__())
# E
print(B.__next__())
# D
print(tuple(B))
# ('C', 'B', 'A')
&lt;/syntaxhighlight&gt;

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>k6vogrxr2ocfhfksvg23hfgzpfoek3a</sha1>
    </revision>
    <revision>
      <id>769293</id>
      <parentid>769289</parentid>
      <timestamp>2026-07-01T07:58:59Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Appelable ({{lang|en|callable}}) */ typo</comment>
      <origin>769293</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="27176" sha1="flpqimajz8k11huga1ox17rpi01mmm2" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

On peut construire une liste à partir de n'importe quel objet itérable avec la commande &lt;code&gt;list(''itérable'')&lt;/code&gt; (voir la section ''[[#Itérable|Itérable]]'' ci-dessous).

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__call__()&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot;, &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
# A, B, C, 
print(&quot;&quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# a, b, c, 
print(&quot;&quot;)
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;sorted()&lt;/code&gt; trie les itérables par ordre croissant, à condition que les éléments soient comparables (typiquement tous des nombres ou bien tous des chaînes de caractères). Le paramètre &lt;code&gt;reverse=True&lt;/code&gt; permet de trier par ordre décroissant. Notez que le résultat est forcément une liste.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
A = sorted(A, reverse = True)
print(type(A), A)
# &lt;class 'list'&gt; [3, 2, 1]
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
B = sorted(B, reverse = True)
print(type(B), B)
# &lt;class 'list'&gt; ['C', 'B', 'A']
C = &quot;123&quot;
C = sorted(C, reverse = True)
print(type(C), C)
# &lt;class 'list'&gt; ['3', '2', '1']
D = dict(a = 1, b = 2, c = 3)
D = sorted(D, reverse = True)
print(type(D), D)
# &lt;class 'list'&gt; ['c', 'b', 'a']
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

{{note |Il ne faut pas confondre itérable et itérateur ''({{lang|en|iterator}})''. Un itérateur représente un flux de données, et est typiquement construit lors de l'utilisation d'une structure &lt;code&gt;for&lt;/code&gt;. On peut construire directement un itérateur avec la fonction &lt;code&gt;iter()&lt;/code&gt;, ou bien avec la fonction &lt;code&gt;reversed()&lt;/code&gt; auquel cas le flux de données est inversé. Les itérateurs possèdent la méthode &lt;code&gt;__next__()&lt;/code&gt; qui renvoie l'élément suivant (et le premier élément au premier appel).

On peut transformer un itérateur en liste ou en n-uplet, mais cela interrompt alors le flux de données (on ne peut plus utiliser &lt;code&gt;.__next__()&lt;/code&gt;).

La manipulation directe d'itérateurs n'est pas très utile, mais connaître cette notion permet de mieux comprendre le fonctionnement de Python.}}
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3, 4, 5]
A = iter(A)
print(A)
# &lt;list_iterator object at 0x00000204181AB3A0&gt;
print(A.__next__())
# 1
print(A.__next__())
# 2
print(list(A))
# [3, 4, 5]

B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;, &quot;E&quot;)
B = reversed(B)
print(B)
# &lt;reversed object at 0x0000020417A7E9B0&gt;
print(B.__next__())
# E
print(B.__next__())
# D
print(tuple(B))
# ('C', 'B', 'A')
&lt;/syntaxhighlight&gt;

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>flpqimajz8k11huga1ox17rpi01mmm2</sha1>
    </revision>
    <revision>
      <id>769295</id>
      <parentid>769293</parentid>
      <timestamp>2026-07-01T08:10:25Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* Appelable ({{lang|en|callable}}) */ utilisation de l'underscore</comment>
      <origin>769295</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="28247" sha1="m98ey1bnlx1n0xdd490soatyqk4ypq5" xml:space="preserve">Python est un langage interprété. Il peut s'utiliser en ligne de commande, l'invite étant représentée par trois chevrons
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
&gt;&gt;&gt; 3+2
5
&lt;/syntaxhighlight&gt;
Le code source peut être mis dans un fichier texte portant l'extension de nom de fichier &lt;code&gt;.py&lt;/code&gt;. Cela requiert donc un éditeur de texte.

Les fichiers que nous allons créer commenceront tous de la manière suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;
La première ligne, appelée ''[[wiktionary:fr:shebang|shebang]]'', n'est pas utile avec l'environnement que nous allons utiliser mais il est  intéressant de la mettre pour assurer une compatibilité du code avec d'autres environnements. Les lignes commençant par &lt;code lang=&quot;python&quot;&gt;import&lt;/code&gt; permettent d'importer des bibliothèques de fonctions ; nous en ajouterons au gré des besoins.

Nous allons utiliser l'environnement de programmation Jupyter, un environnement libre, gratuit et multiplateforme. Jupyter utilise un navigateur Internet comme éditeur de texte et pour l'affichage des résultats.

== Installer  Jupyter ==
[[Fichier:Jupyter logo.svg|vignette|upright=0.5|Jupyter.]]
Nous utilisons la distribution Anaconda : https://www.anaconda.com/

Suivez les instructions d'installation selon votre système. Choisissez « Python 3 ».

{{note|Sous MacOS X, il peut être nécessaire de créer un alias vers le programme Jupyter-lab ; ce programme se trouve habituellement au chemin &lt;code&gt;/anaconda3/bin/jupyter-lab&lt;/code&gt;.}}

Bien entendu, vous pouvez aussi utiliser un éditeur de texte classique. Vous pouvez par exemple vous intéresser à l'éditeur Pulsar&lt;ref&gt;{{lien web |url=https://pulsar-edit.dev/ |titre=Pulsar Edit |site=Pulsar |consulté le=2025-09-02}}.&lt;/ref&gt;, libre et multiplateforme.

== Premiers pas ==

[[Fichier:Jupyter Python Save As Firefox.png|vignette|Fenêtre Python/Jupyter Lab dans Firefox : fonction &lt;code&gt;Save Notebook As…&lt;/code&gt;]]

Lancez le programme &lt;code&gt;Jupyter Lab&lt;/code&gt;. Cela vous ouvre une fenêtre dans votre navigateur Internet. Dans cette fenêtre, choisissez &lt;code&gt;Notebook Python 3&lt;/code&gt; : la page devient un éditeur de texte.

Cette page est organisée en cellules ; une cellule est une zone de texte. Vous pouvez donc avoir plusieurs zones de texte, chacune contenant un élément du programme que vous développez. Dans un premier temps, nous allons travailler avec une seule cellule et l'utiliser comme une ligne de commande.

Dans cette cellule, tapez &lt;code&gt;3 + 2&lt;/code&gt; puis cliquez que le bouton d'évaluation &lt;code&gt;[▶]&lt;/code&gt; : cela affiche logiquement le résultat « 5 »  en dessous.

Vous pouvez sauvegarder cet embryon de programme avec le menu &lt;code&gt;File &amp;gt; Save Notebook As…&lt;/code&gt; Cela crée un fichier portant l'extension de nom de fichier &lt;code&gt;.ipynb&lt;/code&gt;.

{{boîte déroulante/début|titre=Définir un répertoire de départ}}
Jupyter Notebook se présente dans le navigateur Internet ''({{lang|en|web browser}})'', mais s'utilise comme un navigateur de fichiers (Windows Explorer, Finder, GNOME Commander, Konqueror…). Si l'on veut définir le répertoire de départ, il faut ouvrir Jupyter Notebook avec une commande dans l'Anaconda Prompt :
# Ouvrir &lt;code&gt;Anaconda Prompt&lt;/code&gt;.
# Entrer la commande suivante : &lt;code&gt;jupyter notebook --notebook-dir=''chemin''&lt;/code&gt;.
Où &lt;code&gt;''chemin''&lt;/code&gt; est le chemin d'accès au répertoire voulu. Par exemple, si l'on veut utiliser sous Microsoft Windows le répertoire &lt;code&gt;D:\Temp\&lt;/code&gt;, on utilise la commande &lt;code&gt;jupyter notebook --notebook-dir=D:\Temp\&lt;/code&gt;.
{{boîte déroulante/fin}}

== Vocabulaire ==
; Classe, instance
: Python est un langage orienté objet (oo). Les différents objets manipulés — fonctions, valeurs (numériques, chaînes de caractères)… — dérivent d'archétypes appelés « classe ».
: Par exemple, une matrice NumPy est une mise en application de la classe &lt;code&gt;numpy.array&lt;/code&gt;, on dit que « la matrice est une instance de la classe &lt;code&gt;numpy.array&lt;/code&gt; ».
; Méthode
: Une méthode est une fonction associée à une classe. Quand un objet &lt;code&gt;X&lt;/code&gt; est une instance de cette classe, on peut avoir accès à la fonction par la la syntaxe &lt;code&gt;X.''méthode''()&lt;/code&gt;.
: Par exemple, la classe&lt;code&gt;numpy.array&lt;/code&gt; possède une méthode &lt;code&gt;.max()&lt;/code&gt; qui donne la valeur maximale contenue dans la matrice. Si &lt;code&gt;X&lt;/code&gt; est une instance de la classe&lt;code&gt;numpy.array&lt;/code&gt;, alors &lt;code&gt;X.max()&lt;/code&gt; donne le maximum de &lt;code&gt;X&lt;/code&gt;.
: Ci-dessous, nous verrons les méthodes &lt;code&gt;.append()&lt;/code&gt;, &lt;code&gt;.pop()&lt;/code&gt; et &lt;code&gt;.remove()&lt;/code&gt; attachées aux objets de type « liste » (voir la section ''[[#Listes|Listes]]'' ci-après). 
; Module, espace de nom
: Un module est un ensemble de classes (fonctions, type de variables…) développées pour un sujet donné.
: Par exemple, le module NumPy est dédié au calcule numérique, le module Scipy est dédié au calcul scientifique le module Matplotlib est dédié au tracé de données.
: Un module se charge avec la commande &lt;code&gt;import&lt;/code&gt; ; charger un module permet d'avoir accès à de nouveaux type de variable et à de nouvelles fonctions.
: Les modules étant développés séparément, il se peut que des objets de différents modules portent le même nom. Pour éviter les confusions, on fait précéder le nom d'un objet par le nom du module d'où il vient, ou bien de son abréviation. Ainsi, la fonction sinus est fournie par les modules &lt;code&gt;math&lt;/code&gt; et &lt;code&gt;numpy&lt;/code&gt;, et n'est peut-être pas programmée de la même manière dans les deux modules. Si l'on charge les deux modules, on peut appeler &lt;code&gt;math.sin()&lt;/code&gt; et &lt;code&gt;numpy.sin()&lt;/code&gt; (ou bien &lt;code&gt;np.sin()&lt;/code&gt;).

== Commandes élémentaires ==

Nous avons de base les opérateurs mathématiques élémentaires :
* &lt;code&gt;+&lt;/code&gt; : addition ;
* &lt;code&gt;-&lt;/code&gt; : soustraction ;
* &lt;code&gt;*&lt;/code&gt; : multiplication ;
* &lt;code&gt;/&lt;/code&gt; : division ;
* &lt;code&gt;//&lt;/code&gt; : division euclidienne (entière) ;
* &lt;code&gt;%&lt;/code&gt; : reste de la division euclidienne ;
* &lt;code&gt;**&lt;/code&gt; : élévation à la puissance&lt;ref&gt;Note : l'accent circonflexe « &lt;code&gt;^&lt;/code&gt; » ''({{lang|en|caret}})'', utilisé dans de nombreux langages pour l'élévation à la puissance, effectue ici un « ou exclusif » ''(XOR)'' bit à bit.&lt;/ref&gt;.

Exemples : cliquez dans la cellule et ajoutez à la suite
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;6/4 =&quot;, 6//4, &quot;reste&quot;, 6%4)
print(2**0.5) # racine carrée
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 6/4 = 1 reste 2
 1.4142135623730951
La division euclidienne peut aussi se faire avec l'instruction &lt;code&gt;divmod()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = divmod(6, 4)
print(&quot;6/4 =&quot;, a[0], &quot;reste&quot;, a[1])
&lt;/syntaxhighlight&gt;
Nous voyons ici que la commande &lt;code&gt;print()&lt;/code&gt; affiche des informations à l'écran. Les chaînes de caractères peuvent être encadrées de guillemets simple &lt;code&gt;'&lt;/code&gt; ou doubles &lt;code&gt;&quot;&lt;/code&gt;. Le croisillon &lt;code&gt;#&lt;/code&gt; permet de mettre des commentaires.

L'opérateur &lt;code&gt;+&lt;/code&gt; permet de concaténer deux chaînes de caractères.

L'affectation d'une variable se fait avec le signe égal :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 5
print(2*a)
&lt;/syntaxhighlight&gt;
&lt;code&gt;[▶]&lt;/code&gt;
 10

Trois points pour terminer avec les nombres : le type réel à virgule flottante dispose de la méthode &lt;code&gt;.as_integer_ratio()&lt;/code&gt; qui transforme un nombre en fraction.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = 1.5
print(a.as_integer_ratio()) # (3, 2) : fraction 3/2
&lt;/syntaxhighlight&gt;

Ensuite, on peut obtenir l'infini +∞ avec &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; ou  &lt;code&gt;float(&quot;infinity&quot;)&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
1/float(&quot;inf&quot;) # 0.0
&lt;/syntaxhighlight&gt;
On peut également avoir le [[w:fr:NaN|''{{lang|en|not a number}}'']] avec &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt;.

Enfin, l'imaginaire &lt;math&gt;\sqrt{-1}&lt;/math&gt; se note &lt;code&gt;1j&lt;/code&gt;. De manière générale, on peut écrire &lt;code&gt;2j&lt;/code&gt;, &lt;code&gt;3.5j&lt;/code&gt;… Le type complexe dispose de la méthode &lt;code&gt;conjugate()&lt;/code&gt; qui calcule le conjugué.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(1j**2) # (-1+0j)

a = 2 + 3.5j
print(a.conjugate()) # (2-3.5j)
&lt;/syntaxhighlight&gt;

Les commandes de type &lt;code&gt;''x''=&lt;/code&gt;, où ''x'' est un opérateur (&lt;code&gt;+&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, &lt;code&gt;*&lt;/code&gt; ou &lt;code&gt;/&lt;/code&gt;, &lt;code&gt;//&lt;/code&gt;, &lt;code&gt;%&lt;/code&gt;, &lt;code&gt;**&lt;/code&gt;), permet de modifier une variable ''({{lang|en|in-place operator}})'' :
* &lt;code&gt;a += 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a + 0.5&lt;/code&gt; ;
* &lt;code&gt;a -= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a - 0.5&lt;/code&gt; ;
* &lt;code&gt;a *= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a * 0.5&lt;/code&gt; ;
* &lt;code&gt;a /= 0.5&lt;/code&gt; est équivalent à &lt;code&gt;a = a / 0.5&lt;/code&gt; ;
* …

== Premier tracé graphique ==
[[Fichier:Graphe fct carre Python Matplotlib Jupyter.png|vignette|Graphe de la fonction carré avec Python/Matplotlib.]]

Pour effectuer des tracés graphiques, il faut charger la bibliothèque Matplotlib ; nous choisissons l'option &lt;code&gt;pyplot&lt;/code&gt; qui permet d'avoir une syntaxe similaire à Matlab. Pour utiliser cette bibliothèque, il faut écrire &lt;code&gt;import matplotlib.pyplot&lt;/code&gt; ; cela donne l'accès à de nouvelles fonctions telles que &lt;code&gt;matplotlib.pyplot.plot()&lt;/code&gt;.

Comme il est fastidieux d'écrire &lt;code&gt;matplotlib.pyplot&lt;/code&gt; avant chaque commande de cette bibliothèque, nous pouvons utiliser une abréviation, par exemple &lt;code&gt;plt&lt;/code&gt;, introduite par &lt;code&gt;as&lt;/code&gt; lors de l'importation.

Il nous faut aussi pouvoir travailler facilement avec une liste de nombre. Nous chargeons pour cela la bibliothèque NumPy et nous décidons de l'abréger &lt;code&gt;np&lt;/code&gt;.

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 2, 0.1)
y = x**2

plt.plot(x, y, label=&quot;y = x^2&quot;)
plt.xlabel(&quot;x&quot;)
plt.ylabel(&quot;y&quot;)
plt.title(&quot;Graphes de fonctions&quot;)
plt.legend()
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; permet de créer un vecteur (liste de valeurs) allant de 0 à 2 avec un pas de 0,1. La fonction &lt;code&gt;plt.plot()&lt;/code&gt; trace la courbe. Les fonctions &lt;code&gt;plt.xlabel()&lt;/code&gt;, &lt;code&gt;plt.ylabel()&lt;/code&gt; et &lt;code&gt;plt.title()&lt;/code&gt; permettent de mettre des titres aux axes et au graphique. La commande &lt;code&gt;plt.legend()&lt;/code&gt; affiche la légende définie dans la commande &lt;code&gt;plt.plot()&lt;/code&gt;.

Concernant la légende : vous pouvez avoir un rendu de type LaTeX en utilisant les balises &lt;code&gt;$…$&lt;/code&gt; dans le paramètre &lt;code&gt;label&lt;/code&gt; de &lt;code&gt;plt.plot()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
plt.plot(x, y, label=&quot;$y = x^2$&quot;)
&lt;/syntaxhighlight&gt;

Vous remarquerez que la valeur « 2 » n'est pas sur la figure : en effet, selon la logique du « tranchage » ''({{lang|en|slicing}})'', dans l'expression &lt;code&gt;np.arange(0, 2, 0.1)&lt;/code&gt;, le nombre 2 est une extrémité exclue du vecteur. Pour l'intégrer, on peut mettre la première valeur qui ne figure pas, ici &lt;code&gt;2.1&lt;/code&gt; mais cela pourrait poser des problèmes si l'on changeait le pas. Le module NumPy propose une fonction &lt;code&gt;nextafter()&lt;/code&gt; qui indique le réel à virgule flottante le plus proche, on pourrait donc écrire &lt;code&gt;np.arange(0, np.nextafter(2, 3), 0.1)&lt;/code&gt; (le nombre 3 servant juste à indiquer que l'on veut un nombre supérieur à 2). Mais le plus simple consiste à utiliser la fonction &lt;code&gt;np.linspace()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2, 20) # 20 valeurs entre 0 et 2 inclus
&lt;/syntaxhighlight&gt;

== Les chaînes de caractères ==

Une chaîne de caractères est simplement mise entre des guillemets simples &lt;code&gt;'…'&lt;/code&gt; ''ou'' des guillemets doubles &lt;code&gt;&quot;…&quot;&lt;/code&gt;. Si le texte contient une apostrophe, on utilise des guillemets doubles ; dans &lt;code&gt;&quot;d'Artagnan&quot;&lt;/code&gt;, le « &lt;code&gt;'&lt;/code&gt; » est interprété comme un caractère et non comme un délimiteur de chaîne. Et à l'inverse, si on veut utiliser des guillemets doubles dans la chaîne, on la délimite par des guillemets simples : &lt;code&gt;'&quot;En garde !&quot; dit-il'&lt;/code&gt;. On peut aussi utiliser la barre de fraction inversée comme « caractère d'échappement » : &lt;code&gt;'&quot;En garde !&quot; s\'exclama d\'Aragnan'&lt;/code&gt;.

Pour éviter d'utiliser les échappements &lt;code&gt;\'&lt;/code&gt; ou &lt;code&gt;\&quot;&lt;/code&gt;, si l'encodage du fichier est en Unicode (typiquement utf-8), il est également possible d'utiliser les caractères typographiques : ’ – « – » – “ – ”. Mais ces caractères ne sont pas disponibles facilement à partir du clavier seul.

Dans une variable, les caractères sont numérotés de 0 à ''n'' – 1 (si ''n'' est le nombre de caractères de la chaîne) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
a[2] # t
&lt;/syntaxhighlight&gt;
Si l'on veut extraire plusieurs caractères, on utilise deux-points, sous la forme &lt;code&gt;début:fin&lt;/code&gt; mais il faut bien comprendre que les numéros correspondent en fait aux interstices entre les caractères. Ainsi, &lt;code&gt;0:1&lt;/code&gt; va extraire uniquement le premier caractère (celui compris entre les interstices 0 et 1), &lt;code&gt;0:2&lt;/code&gt; va extraire les deux premiers caractères…

L'indice &lt;code&gt;-1&lt;/code&gt; correspond à l'interstice entre le dernier et l'avant-dernier caractère. Pour résumer :
&lt;syntaxhighlight lang=&quot;text&quot;&gt;
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
&lt;/syntaxhighlight&gt;
Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = &quot;Python&quot;
print(a[0:3]) # Pyt
print(a[3:-1]) # ho
&lt;/syntaxhighlight&gt;
La chaîne intégrale s'obtient avec &lt;code&gt;a[0:]&lt;/code&gt; ou &lt;code&gt;a[:]&lt;/code&gt;. La chaîne sauf le dernier caractère s'obtient avec &lt;code&gt;a[:-1]&lt;/code&gt; ; la chaîne du troisième au dernier caractère s'obtient avec &lt;code&gt;a[2:]&lt;/code&gt;. Le dernier caractère s'obtient avec &lt;code&gt;a[-1:]&lt;/code&gt; ou bien &lt;code&gt;a[len(a)]&lt;/code&gt;.

Cette méthode qui consiste à définir des interstices est appelée « découpage en tranches, tranchage », en anglais ''{{lang|en|slicing}}''.

Concernant les caractères non-alphanumériques, on peut utiliser les codes hexadécimaux des caractères Unicode avec l'échappement &lt;code&gt;\u&lt;/code&gt; : le caractère U+''xxxx'' s'obtient avec &lt;code&gt;&quot;\u''xxxx''&lt;/code&gt;&quot;. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(&quot;Bonjour \u263A&quot;)
# Bonjour ☺
&lt;/syntaxhighlight&gt;

On peut aussi utiliser les entités HTML :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
import html
…
print(html.entities.html5[&quot;alpha;&quot;])
# α
&lt;/syntaxhighlight&gt;
L'entité HTML &lt;code&gt;&amp;amp;''xxx'';&lt;/code&gt; s'obtient par &lt;code&gt;html.entities.html5[&quot;''xxx'';&quot;]&lt;/code&gt;, donc en enlevant la perluète.

== Listes et n-uplets ==

[[Fichier:Slicing index Python.svg|thumb|Découpage en tranche ''(slicing)'' : indexation des éléments à extraire d'une chaîne, d'une liste  ou d'un n-uplet en Python.]]

=== Listes ===

Une liste est une suite d'éléments numérotés. On peut mélanger des nombres et des chaînes de caractère. Pour déclarer une liste, il suffit d'écrire les éléments entre crochets et séparés des virgules. Pour extraire un élément ou un groupe d'éléments, on utilise également le tranchage.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
print(a[2:4]) # ['c', 1]
&lt;/syntaxhighlight&gt;
On peut aussi remplacer une partie de la liste, par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3]
a[3] = &quot;foo&quot;
print(a) # ['a', 'b', 'c', 'foo', 2, 3]
&lt;/syntaxhighlight&gt;
Pour ajouter un élément, on peut utiliser la concaténation
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a + 4
print(a) # ['a', 'b', 'c', 'foo', 2, 3, 4]
&lt;/syntaxhighlight&gt;
ou bien la « méthode » &lt;code&gt;append()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.append(4)
&lt;/syntaxhighlight&gt;
Une méthode est une fonction attachée à un type d'objet ; ici, la fonction &lt;code&gt;append()&lt;/code&gt; est attachée aux listes.

Pour effacer l'élément ''i'', on utilise
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
del a[i-1]
&lt;/syntaxhighlight&gt;
Si on veut obtenir la valeur de l'élément avant de le supprimer :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
valeur = a.pop([i-1])
&lt;/syntaxhighlight&gt;
Et pour effacer le premier élément dont la valeur est ''x'' :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.remove(x)
&lt;/syntaxhighlight&gt;
La méthode &lt;code&gt;.sort()&lt;/code&gt; permet de classer les éléments par ordre croissant, mais uniquement s'ils sont comparable. Typiquement, les éléments doivent être soit tous des nombres, soit tous des chaînes de caractères, mais on ne peut pas mélanger ces deux types ; mais on peut mélanger les entiers et les réels. Pour trier la liste &lt;code&gt;a&lt;/code&gt; par ordre décroissant, on utilise &lt;code&gt;a.sort(reverse=True)&lt;/code&gt;.

Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = [1, 3, 2, 4]
print(a)
# [1, 3, 2, 4]
a.sort()
print(a)
# [1, 2, 3, 4]
a.remove(2)
print(a)
# [1, 3, 4]
&lt;/syntaxhighlight&gt;

On peut construire une liste à partir de n'importe quel objet itérable avec la commande &lt;code&gt;list(''itérable'')&lt;/code&gt; (voir la section ''[[#Itérable|Itérable]]'' ci-dessous).

=== N-uplets ''({{lang|en|tuples}})'' ===

Un n-uplet, en anglais ''{{lang|en|tuple}}'', est similaire à une liste mais on ne peut pas la modifier (ajouter ou changer un élément). L'avantage est qu'elle prend moins de place en mémoire. Elle est définie simplement en séparant les éléments par des virgules. Pour plus de clarté, on peut la mettre entre parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b = &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3
# ou bien
b = (&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, 1, 2, 3)
&lt;/syntaxhighlight&gt;
Pour faire un n-uplet d'un seul élément, il faut mettre une virgule après l'élément. Pour des raisons de lisibilité, il est conseillé d'utiliser alors des parenthèses.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
c = (&quot;un seul élément&quot;,)
&lt;/syntaxhighlight&gt;

Notez que la commande &lt;code&gt;print&lt;/code&gt; s'applique à un n-uplet, la présence de parenthèses est donc optionnelle.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print &quot;a =&quot;, 4
print(&quot;a =&quot;, 4)
&lt;/syntaxhighlight&gt;

== Les booléens ==

Les deux valeurs booléennes sont &lt;code&gt;True&lt;/code&gt; et &lt;code&gt;False&lt;/code&gt;. Ce sont notamment les résultats des comparaisons avec &lt;code&gt;==&lt;/code&gt; (égalité), &lt;code&gt;!=&lt;/code&gt; (différence), &lt;code&gt;&amp;lt;&lt;/code&gt;, &lt;code&gt;&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;=&lt;/code&gt; et &lt;code&gt;&amp;gt;=&lt;/code&gt;. On peut leur appliquer les opérateurs logiques &lt;code&gt;not&lt;/code&gt;, &lt;code&gt;and&lt;/code&gt; et &lt;code&gt;or&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = False
b = 4 &lt;= 5
print(a and b) # False
&lt;/syntaxhighlight&gt;
L'opérateur &lt;code&gt;&amp;&lt;/code&gt; est équivalent à &lt;code&gt;and&lt;/code&gt; ; le tube &lt;code&gt;|&lt;/code&gt; est équivalent à &lt;code&gt;or&lt;/code&gt;. Comme pour les opérations arithmétiques, on peut modifier une variable avec &lt;code&gt;&amp;=&lt;/code&gt; et &lt;code&gt;|=&lt;/code&gt;. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(True &amp; False) # False
print(True - False) # True
a = True
a &amp;= False # équivalent à a = a &amp; False
print(a) # False
&lt;/syntaxhighlight&gt;

On a normalement pas besoin de tester un booleen : il est son propre test. Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
Va afficher « vrai ». Si l'on veut toutefois tester la valeur, on utilise alors &lt;code&gt;is&lt;/code&gt; (et non pas &lt;code&gt;==&lt;/code&gt; comme pour les autres types, même si cela marche aussi avec lees booléens) :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = True
if a is True:
    print(&quot;vrai&quot;)
&lt;/syntaxhighlight&gt;
{{voir|[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle]]}}

== Les ensembles et les dictionnaires ==

Un ensemble est une liste mais dont l'ordre n'a pas d'importance. Pour cela, il suffit de mettre les éléments entre accolades &lt;code&gt;{…}&lt;/code&gt;. On peut aussi utiliser l'instruction &lt;code&gt;set()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
set([1, 2, 3]) # {1, 2, 3}
&lt;/syntaxhighlight&gt;
Les opérations possibles sont :
* &lt;code&gt;a in E&lt;/code&gt; : teste si un élément ''a'' fait partie de l'ensemble E (booléen) ;
* &lt;code&gt;E|F&lt;/code&gt; : union des ensembles E et F ;
* &lt;code&gt;E&amp;F&lt;/code&gt; : intersection des ensembles E et F ;
* &lt;code&gt;E-F&lt;/code&gt; : éléments de E qui ne sont pas dans F ;
* &lt;code&gt;E^F&lt;/code&gt; : éléments qui sont dans E ou dans F mais ''pas'' dans les deux.

Un dictionnaire est un ensemble de paires « (mot-clef ; valeur) ». Il s'obtient aussi avec des accolades : &lt;code&gt;{ &quot;mot-clefs1&quot; : valeur1, &quot;mot-clefs2&quot; : valeurs2, …}&lt;/code&gt;. On peut aussi utiliser la commande &lt;code&gt;dict()&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
dico = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
print(dico[&quot;b&quot;]) # 2
&lt;/syntaxhighlight&gt;
Notez que des accolades vides &lt;code&gt;{}&lt;/code&gt; créent le dictionnaire vide.

== Les espaces de noms ==

De nombreux modules additionnels sont développés pour le langage Python. Lorsque l'on charge un module, pour appeler les fonctions ou classe qu'il apporte, il faut rajouter le nom du module devant le nom de la fonction. Ainsi, si plusieurs modules définissent des fonctions de même nom, il n'y a pas d'ambiguïté. Par exemple, si l'on veut utiliser la fonction &lt;code&gt;mean()&lt;/code&gt; apporté par le module &lt;code&gt;numpy&lt;/code&gt;, il faut taper &lt;code&gt;numpy.mean()&lt;/code&gt;.

Le préfixe du nom de fonction ou de classe est appelé l'espace de nom.

Il est possible d'abréger l'espace de nom. Ainsi, ci-dessus, nous avons abrégé &lt;code&gt;numpy&lt;/code&gt; en &lt;code&gt;np&lt;/code&gt; et ainsi, pour appeler la fonction, il suffit d'écrire &lt;code&gt;np.mean()&lt;/code&gt;

== Installation et mise à jour de modules ==
Il est possible que certains modules soient absents de votre installation. Pour les installer, on utilise la commande &lt;code lang=&quot;python&quot;&gt;pip&lt;/code&gt; ''({{lang|en|Python installer program}})'', avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install nomDuModule
&lt;/syntaxhighlight&gt;
Si l'on veut mettre à jour un module avec un version plus récente, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
pip install --upgrade nomDuModule
&lt;/syntaxhighlight&gt;

== Appelable ''({{lang|en|callable}})'' ==
Dans Python, un « appelable » ''({{lang|en|callable}})'' est un objet qui dispose d'une méthode &lt;code&gt;__call__()&lt;/code&gt;. De manière moins jargonnante, c'est une fonction, un objet que l'on peut appeler avec une paire de parenthèses. Par exemple, l'instruction &lt;code&gt;divmod()&lt;/code&gt; est un appelable.

Certaines fonctions renvoient un n-uplet. Par exemple, lorsque 'on fait une régression linéaire avec la commande &lt;code&gt;np.linalg.lstsq()&lt;/code&gt;, on obtient un n-uplet de quatre objets (voir ''[[../Régression_et_optimisation#Régression_linéaire|Régression_et_optimisation &amp;gt; Régression_linéaire]]''). On peut récupérer soit le n-uplet en entier, soit les éléments un par un. En utilisant l'exemple de la section sur la régression :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
resultat = np.linalg.lstsq(X, y)
print(type(resultat))
# &lt;class 'tuple'&gt;
print(resultat)
# (array([4.60203769, 1.90735762]), array([3.16699277]), np.int32(2), array([5.03896036, 1.20456788]))
(a, b, c, d) = np.linalg.lstsq(X, y)
print(a, b, c, d)
# [4.60203769 1.90735762] [3.16699277] 2 [5.03896036 1.20456788]
&lt;/syntaxhighlight&gt;
Si l'on ne veut pas d'un des objets, on peut le remplacer par le tiret de soulignement ''({{lang|en|underscore}})'' « &lt;code&gt;_&lt;/code&gt; ».
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
(a, _, _, _) = np.linalg.lstsq(X, y)
print(a)
# [4.60203769 1.90735762]
&lt;/syntaxhighlight&gt;

== Itérable ==
Dans Python, un « itérable » est un objet qui peut être utilisé dans une boucle &lt;code&gt;for&lt;/code&gt; (voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Structures_de_contrôle|Éléments_de_programmation &amp;gt; Structures_de_contrôle]]''). Il s'agit de :
* liste : &lt;code&gt;[…]&lt;/code&gt; ;
* n-uplet ''({{lang|en|tuple}})'' : &lt;code&gt;(…)&lt;/code&gt; ;
* chaîne de caractère : &lt;code&gt;&quot;…&quot;&lt;/code&gt; ou &lt;code&gt;'…'&lt;/code&gt; ;
* d'ensemble : &lt;code&gt;set([…])&lt;/code&gt; ;
* de dictionnaires : &lt;code&gt;dict(…)&lt;/code&gt;
* d'objet &lt;code&gt;range()&lt;/code&gt; ;
* d'objet NumPy &lt;code&gt;np.array()&lt;/code&gt; ou &lt;code&gt;np.matrix()&lt;/code&gt;.
Exemples :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
for i in A:
    print(i, end=&quot;, &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
for i in B:
    print(i, end=&quot; &quot;)
# A, B, C, 
print(&quot;&quot;)
C = &quot;123&quot;
for i in C:
    print(i, end=&quot; &quot;)
# 1, 2, 3, 
print(&quot;&quot;)
D = dict(a = 1, b = 2, c = 3)
for i in D:
    print(i, end=&quot; &quot;)
# a, b, c, 
print(&quot;&quot;)
&lt;/syntaxhighlight&gt;
Le tranchage ''(slicing)'' est ''en général'' utilisable sur les itérables ; il ne s'applique pas aux ensembles et dictionnaires.

La commande &lt;code&gt;sorted()&lt;/code&gt; trie les itérables par ordre croissant, à condition que les éléments soient comparables (typiquement tous des nombres ou bien tous des chaînes de caractères). Le paramètre &lt;code&gt;reverse=True&lt;/code&gt; permet de trier par ordre décroissant. Notez que le résultat est forcément une liste.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3]
A = sorted(A, reverse = True)
print(type(A), A)
# &lt;class 'list'&gt; [3, 2, 1]
B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;)
B = sorted(B, reverse = True)
print(type(B), B)
# &lt;class 'list'&gt; ['C', 'B', 'A']
C = &quot;123&quot;
C = sorted(C, reverse = True)
print(type(C), C)
# &lt;class 'list'&gt; ['3', '2', '1']
D = dict(a = 1, b = 2, c = 3)
D = sorted(D, reverse = True)
print(type(D), D)
# &lt;class 'list'&gt; ['c', 'b', 'a']
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;enumerate()&lt;/code&gt; renvoie la liste des éléments de l'itérable en l'associant à son indice (pour la deuxième impression, nous utilisons la définition en compréhension, voir ''[[Python pour le calcul scientifique/Éléments_de_programmation#Définition_en_compréhension|Éléments_de_programmation &amp;gt; Définition_en_compréhension]]'') :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
print(list(enumerate(A)))
# [(0, 'a'), (1, 'b'), (2, 'c')]
print([a for i, a in enumerate(A) if i % 2 == 0]) # filtre les indices pairs
# ['a', 'c']
&lt;/syntaxhighlight&gt;
On peut utiliser un paramètre &lt;code&gt;start ''i''&lt;/code&gt; pour commencer l'énumération à l'élément ''i'' + 1.

La commande &lt;code&gt;zip()&lt;/code&gt; permet d'itérer sur deux itérables en parallèle.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]
B = [6, 7, 8]
for i in zip(A, B)
# ('a', 6)
# ('b', 7)
# ('c', 8)
&lt;/syntaxhighlight&gt;
On peut utiliser une liste de booléens pour extraire une partie d'un itérable, avec la fonction &lt;code&gt;compress()&lt;/code&gt; du module &lt;code&gt;itertools&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
from itertools import compress

A = [1, 2, 3, 4, 5]
booleen = [True, False, True, False, True]
print(list(compress(A, booleen)))
# [1, 3, 5]
&lt;/syntaxhighlight&gt;
Cette fonction est beaucoup plus performante qu'une extraction itérative de type &lt;code&gt;[a for i, a in enumerate(A) if booleen[i]]&lt;/code&gt; ou &lt;code&gt;[a for (a, b) in zip(A, booleen) if b]&lt;/code&gt;.

{{note |Il ne faut pas confondre itérable et itérateur ''({{lang|en|iterator}})''. Un itérateur représente un flux de données, et est typiquement construit lors de l'utilisation d'une structure &lt;code&gt;for&lt;/code&gt;. On peut construire directement un itérateur avec la fonction &lt;code&gt;iter()&lt;/code&gt;, ou bien avec la fonction &lt;code&gt;reversed()&lt;/code&gt; auquel cas le flux de données est inversé. Les itérateurs possèdent la méthode &lt;code&gt;__next__()&lt;/code&gt; qui renvoie l'élément suivant (et le premier élément au premier appel).

On peut transformer un itérateur en liste ou en n-uplet, mais cela interrompt alors le flux de données (on ne peut plus utiliser &lt;code&gt;.__next__()&lt;/code&gt;).

La manipulation directe d'itérateurs n'est pas très utile, mais connaître cette notion permet de mieux comprendre le fonctionnement de Python.}}
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = [1, 2, 3, 4, 5]
A = iter(A)
print(A)
# &lt;list_iterator object at 0x00000204181AB3A0&gt;
print(A.__next__())
# 1
print(A.__next__())
# 2
print(list(A))
# [3, 4, 5]

B = (&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;, &quot;E&quot;)
B = reversed(B)
print(B)
# &lt;reversed object at 0x0000020417A7E9B0&gt;
print(B.__next__())
# E
print(B.__next__())
# D
print(tuple(B))
# ('C', 'B', 'A')
&lt;/syntaxhighlight&gt;

== Notes et références ==
{{références}}

----
[[../|Python pour le calcul scientifique]] &amp;lt; [[../|↑]] &amp;gt; [[../Premiers programmes|Premiers programmes]]

{{DEFAULTSORT:Decouverte de Python et de Jupyter}}
[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>m98ey1bnlx1n0xdd490soatyqk4ypq5</sha1>
    </revision>
  </page>
  <page>
    <title>Python pour le calcul scientifique/Manipulation de matrices</title>
    <ns>0</ns>
    <id>72889</id>
    <revision>
      <id>769248</id>
      <parentid>768706</parentid>
      <timestamp>2026-06-30T12:17:36Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Trouver une valeur */ corr.</comment>
      <origin>769248</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="26261" sha1="r21iyanvz2zwkcmec3wogltj0x2o13m" xml:space="preserve">Les matrices sont un élément primordial du calcul scientifique sur ordinateur pour deux raisons :
# L'algèbre linéaire est au cœur de nombreux calculs.
# Les matrices sont l'élément de base du calcul vectorisé qui permet un gain de temps appréciable.
Pour pouvoir expliter les matrices, il faut charger le module NumPy ; nous utilisons également Matplotlib pour les graphiques. Ainsi, les programmes contiennent tous au début :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;

== Rappels et complément sur le tranchage ==
Soit une liste L composée de ''n'' éléments.
* Les éléments sont numérotés de 0 à ''n'' – 1.
* Le premier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[0]&lt;/code&gt;.
* Le i-ème élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[''i'' - 1]&lt;/code&gt;.
* L'avant-dernier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[-2]&lt;/code&gt;.
* Le dernier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[-1]&lt;/code&gt;.
* La sous-liste composée des éléments contigus ''i'' à ''j'' s'obtient par &lt;code lang=&quot;python&quot;&gt;L[''i'' - 1:j]&lt;/code&gt;.
Ainsi, &lt;code lang=&quot;python&quot;&gt;L[0:1]&lt;/code&gt; va extraire le premier élément, &lt;code lang=&quot;python&quot;&gt;L[1:-1]&lt;/code&gt; va extraire tous les éléments sauf le premier et le dernier.

{{voir|[[Python_pour_le_calcul_scientifique/Découverte_de_Python_et_de_Jupyter#Itérable|Découverte_de_Python_et_de_Jupyter &amp;gt; Itérable]]}}

NumPy fournit des fonctions permettant de manipuler les matrices :
* &lt;code lang=&quot;python&quot;&gt;np.append(A, B)&lt;/code&gt; : fusionne les vecteurs A et B ;&lt;br /&gt; s'il s'agit de matrices ou de tenseurs, la fonction les « aplatit », les transforme en vecteur ;&lt;br /&gt;si l'on veut intégrer B dans A, on utilise &lt;code lang=&quot;python&quot;&gt;A = np.append(A, B)&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.append(A, B, axis = ''i'')&lt;/code&gt; : fusionne les tenseurs selon l'indice ''i'' (&lt;code&gt;0&lt;/code&gt; pour le premier indice, &lt;code&gt;1&lt;/code&gt; pour le deuxième…) ;
* &lt;code lang=&quot;python&quot;&gt;np.insert(A, i, m)&lt;/code&gt; : insère le vecteur ''m'' dans le vecteur A (ou la matrice A aplatie) à l'emplacement ''i'' ;
* &lt;code lang=&quot;python&quot;&gt;np.insert(A, i, M, axis = ''j'')&lt;/code&gt; : insère le tenseur M dans le tenseur A à l'emplacement ''i'' de l'indice ''j'' ;
* &lt;code lang=&quot;python&quot;&gt;np.delete(A, I)&lt;/code&gt; : efface les éléments définis par le tranchage I du vecteur A (ou de la matrice A aplatie) ;
* &lt;code lang=&quot;python&quot;&gt;np.delete(A, I, axis = ''j'')&lt;/code&gt; : efface les éléments définis par le tranchage I selon l'indice ''j'' du tenseur A.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1]])
B = np.array([[2, 3, 4]])
C = np.append(A, B, axis=1)
print(A, B, C, sep=&quot;\n&quot;)
# [[1]]
# [[2 3 4]]
# [[1 2 3 4]]
D = np.array([[10, 20, 30, 40]])
E = np.append(C, D, axis=0)
print(E)
# [[ 1  2  3  4]
#  [10 20 30 40]]
&lt;/syntaxhighlight&gt;
On peut utiliser &lt;code&gt;np.r_[A, B]&lt;/code&gt; pour concaténer A et B en ligne ''(row), et &lt;code&gt;np.c_[A, B]&lt;/code&gt; pour les concaténer en colonne.

On peut extraire une sous-matrice à partir d'une matrice de booléens :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1, 2], [3, 4], [5, 6]])
booleen = np.logical_or(A==1, A==3)
print(booleen)
# [[ True False]
#  [ True False]
#  [ False False]]
print(A[booleen])
# [1 3]

booleen = np.logical_or(A[:, 0]==1, A[:, 0]==3)
print(booleen)
# [ True  True False]
print(A[booleen])
# [[1 2]
#  [3 4]]
print(A[booleen][:, 1])
# [2 4]
&lt;/syntaxhighlight&gt;

== Différence entre ''array'' et ''matrix'' ==
Il existe deux types d'objet NumPy pour décrire les matrices : les objets ''array'' (tableau, classe &lt;code&gt;ndarray&lt;/code&gt;) et les objets ''matrix'' (matrice, classe &lt;code&gt;matrix&lt;/code&gt;).
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1, 2], [3, 4], [5, 6]])
B = np.matrix([[1, 2], [3, 4], [5, 6]])
&lt;/syntaxhighlight&gt;
Il y a trois différences :
* les objets ''array'' peuvent être de n'importe quelle dimension : 0 (scalaire), 1 (vecteur), 2 (matrice), 3 (tenseur d'ordre 3)… alors qu'un objet ''matrix'' est nécessairement de dimension 2 ;
* les opération sur les objets ''matrix'' sont par défaut des opérations matricielles ; ainsi, la multiplication &lt;code&gt;A * B&lt;/code&gt; va être une multiplication terme à terme si A et B sont des ''array'', et une multiplication matricielle si A et B sont des ''matrix'' ; pour avoir la multiplication matricielle entre ''array'', il faut utiliser &lt;code&gt;a@b&lt;/code&gt; ou &lt;code&gt;np.dot(a,b)&lt;/code&gt; ;
* si une matrice A est inversible, alors avec un objet ''matrix'', on peut utiliser la méthode &lt;code&gt;A.I&lt;/code&gt; ; si A est un objet ''array'', il faut utiliser &lt;code&gt;np.linalg.inv(A)&lt;/code&gt;.

La classe &lt;code&gt;matrix&lt;/code&gt; a été dépréciée, il est recommandé de n'utiliser que la classe &lt;code&gt;ndarray&lt;/code&gt;. Nous n'utiliserons donc pas la classe &lt;code&gt;matrix&lt;/code&gt;.

== Définir un tenseur ==
Un tenseur est similaire à une liste mais il est défini par la fonction &lt;code&gt;np.array()&lt;/code&gt;. La définition et l'extraction de composante utilise la méthode du découpage en tranches ''({{lang|en|slicing}})''.

'''Exemples'''
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 3, 5, 7]) # vecteur
bc = np.array([[1], [2], [3], [4]]) # matrice 4 × 1 (matrice colonne)
bl = np.array([[1, 2, 3, 4]]) # matrice 1 × 4 (matrice ligne)
c = np.array([[1, 2, 3],
              [2, 3, 4],
              [3, 4, 5]]) # matrice 3 × 3
d = np.array([[[1,  2, 3],
               [2,  3, 4]],
              [[10, 9, 8],
               [ 7, 6, 5]]]) # tenseur d'ordre 3, de dimension 3 × 2 × 2
                       
&lt;/syntaxhighlight&gt;
Notez que dans NumPy, un vecteur n'est pas la même chose qu'une matrice ligne ou colonne. Un vecteur de dimension ''n'' est un tenseur d'ordre 1 et de dimension ''n'' ; une matrice ligne ou colonne est un tenseur d'ordre 2 et de dimension 1 × ''n'' ou ''n'' × 1.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 2, 3])
b = np.array([[1, 2, 3]])
c = np.array([[1], [2], [3]])
print(a.size, b.size, c.size) # 3 3 3
print(a.ndim, b.ndim, c.ndim) # 1 2 2
print(a.shape, b.shape, c.shape) # (3,) (1, 3) (3, 1)
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; est similaire à la fonction &lt;code&gt;range()&lt;/code&gt; pour les liste ; elle génère un vecteur de réels. La fonction &lt;code&gt;np.linspace()&lt;/code&gt; permet également de créer un vecteur de même type, mais on indique le dernier nombre alors que la règle du découpage en tranches fait que le nombre maximal indiqué à &lt;code&gt;np.arange()&lt;/code&gt; est le premier nombre qui ne ''figure pas'' dans le vecteur.). La fonction &lt;code&gt;np.zeros()&lt;/code&gt; génère une matrice nulle, &lt;code&gt;np.zeros_like()&lt;/code&gt; une matrice nulle ayant les dimensions d'une matrice fournie comme modèle. De même, &lt;code&gt;np.ones()&lt;/code&gt; et &lt;code&gt;np.ones_like()&lt;/code&gt; crée des matrices, dont toutes les composantes sont à 1. La fonction &lt;code&gt;np.eye()&lt;/code&gt; crée une matrice unité.

'''Exemples'''
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
e = np.arange(0, 2, 0.1) # vecteur [0, 0.1, 0.2…, 1.8, 1.9]
f = np.linspace(0, 2, 5) # 5 nombres entre 0 et 2 soit le vecteur [0, 0.5, 1, 1.5, 2]
g = np.zeros(3) # vecteur nul de dimension 3
h = np.zeros((3, 3)) # matrice nulle 3 × 3
k = np.ones_like(a) # matrice de 1 de même dimension que a 
u = np.eye(3) # matrice unité 3 × 3                  
&lt;/syntaxhighlight&gt;
Le paramètre &lt;code&gt;dtype&lt;/code&gt; permet de forcer le type. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 2, 3], dtype=&quot;complex&quot;)
k = np.ones_like(a, dtype=&quot;int&quot;)
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;np.linspace()&lt;/code&gt; peut créer des matrices colonne : on donne la première et la dernière ligne ; par exemple : :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
np.linspace([1, -1], [10, -10], 4)
# [[  1.  -1.]
#  [  4.  -4.]
#  [  7.  -7.]
#  [ 10. -10.]]
&lt;/syntaxhighlight&gt;
Les commandes &lt;code&gt;np.geomspace()&lt;/code&gt; et &lt;code&gt;np.geomspace()&lt;/code&gt; fonctionnent comme &lt;code&gt;np.linspace()&lt;/code&gt;, mais avec une progression logarithmique. La commande &lt;code&gt;np.geomspace(a, b, n)&lt;/code&gt; crée un vecteur (ou une matrice colonne) allant de ''a'' à ''b'' alors que &lt;code&gt;np.logspace(a, b, n)&lt;/code&gt; crée un vecteur (ou une matrice colonne) allant de 10&lt;sup&gt;''a''&lt;/sup&gt; à 10&lt;sup&gt;''b''&lt;/sup&gt;.

La méthode &lt;code&gt;.reshape()&lt;/code&gt; remet en forme une matrice. Par exemple, pour transformer un vecteur de dimension 9 en une matrice 3 × 3 :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.arange(1, 10)
b = a.reshape(3, 3)
# ou bien directement
c = np.arange(1, 10).reshape(3, 3)         
&lt;/syntaxhighlight&gt;
Avec la méthode &lt;code&gt;.reshape()&lt;/code&gt;, on peut utiliser la valeur –1 pour une des dimensions ; sa valeur est alors automatiquement calculée en fonction du nombre d'éléments et de l'autre dimension. On peut aussi utiliser une dimension vide ; cela crée alors un vecteur. Par exemple, pour une matrice M quelconque :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M.reshape(-1, 1) # crée une matrice colonne
M.reshape(1, -1) # crée une matrice ligne
M.reshape(-1,) # crée un vecteur
&lt;/syntaxhighlight&gt;


La méthode &lt;code&gt;.fill()&lt;/code&gt; remplit la matrice avec un scalaire :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b.fill(5) # remplace les valeurs de b par la valeur 5
&lt;/syntaxhighlight&gt;

== Extraction matricielle ==
Si l'on veut extraire les colonnes 1 et 3 pour toutes les lignes d'une matrice M, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M[:, [0, 2]]
&lt;/syntaxhighlight&gt;

== Trouver une valeur ==
Pour trouver une valeur, on utilise la fonction &lt;code&gt;where()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
print(A)
# [[1 2]
#  [3 4]]
B = np.where(A == 3)
print(B)
# (array([1]), array([0])
print(B[0][0], B[1][0])
# 1 0
C = np.where(A == 5)
print(C)
# (array([], dtype=int64), array([], dtype=int64))
print(len(C[0]))
# 0
&lt;/syntaxhighlight&gt;
Notez que &lt;code&gt;where()&lt;/code&gt; peut servir à construire une matrice à partir de deux autres matrices selon une condition. Par exemple, pour comparer les éléments deux à deux et sélectionner le plus grand :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
B = np.array([[0, 1], [4, 5]])
C = np.where(A &gt; B, A, B)
print(C)
# [[1 2]
#  [4 5]
&lt;/syntaxhighlight&gt;
La syntaxyte générale est &lt;code&gt;C = np.where(condition, A, B)&lt;/code&gt; où &lt;condition&lt;/code&gt; est une matrice de booléens ; pour un indice (''i'', ''j''), si &lt;code&gt;condition[i, j]&lt;/code&gt; est vrai, alors &lt;code&gt;C[i, j]&lt;/code&gt; vaut &lt;code&gt;A[i, j]&lt;/code&gt;, sinon elle vaut &lt;code&gt;B[i, j]&lt;/code&gt;.

== Assemblage de matrices ==
Si l'on veut regrouper deux matrices, on utilise la commande &lt;code&gt;np.concatenate()&lt;/code&gt;. On utilise le paramètre ''axis'' pour indiquer si l'on empile les matrices l'une au-dessus de l'autre (&lt;code&gt;axis=0&lt;/code&gt;) ou bien l'une derrière l'autre (&lt;code&gt;axis=1&lt;/code&gt;). Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1 ,2], [3, 4]])
B = np.array([[5 ,6], [7, 8]])
C = np.concatenate((A, B), axis = 0)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]
D = np.concatenate((A, B), axis = 1)
# [[1 2 5 6]
#  [3 4 7 8]]
&lt;/syntaxhighlight&gt;
Si l'on veut transformer deux vecteurs en une matrice de deux colonnes, chaque vecteur occupant une colonne :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([1 ,2])
B = np.array([3 ,4])
C = np.concatenate((A.reshape(-1, 1), B.reshape(-1, 1)), axis = 1)
# [[1 3]
#  [2 4]]
&lt;/syntaxhighlight&gt;

== Opérations matricielles ==

Les quatre opérations classiques &lt;code lang=&quot;python&gt;+&lt;/code&gt;, &lt;code lang=&quot;python&gt;-&lt;/code&gt; et &lt;code lang=&quot;python&gt;/&lt;/code&gt; ne fonctionnent qu'entre tenseurs de mêmes dimensions et sont des opérations élément par élément ''({{lang|en|elementwise operations}})'' :
* &lt;code lang=&quot;python&quot;&gt;(A + B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] + B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;(A - B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] - B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;(A / B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] / B[i, j, k]&lt;/code&gt;.
La multiplication élément par élément se fait avec
: &lt;code lang=&quot;python&quot;&gt;np.multiply(A, B)&lt;/code&gt; qui vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] * B[i, j, k]&lt;/code&gt;.
De même, les fonctions &lt;code lang=&quot;python&gt;np.add()&lt;/code&gt;, &lt;code lang=&quot;python&gt;np.subtract()&lt;/code&gt;, &lt;code lang=&quot;python&gt;np.multiply()&lt;/code&gt; et &lt;code lang=&quot;python&gt;np.divide()&lt;/code&gt; effectuent des opérations élément par élément sur des tenseurs de mêmes dimensions :
* &lt;code lang=&quot;python&quot;&gt;np.add(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] + B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.subtract(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] - B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.multiply(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] * B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.divide(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] / B[i, j, k]&lt;/code&gt;.
La multiplication matricielle, au sens de l'algèbre linéaire, se fait avec les fonctions &lt;code lang=&quot;python&quot;&gt;np.dot()&lt;/code&gt; ou &lt;code lang=&quot;python&quot;&gt;np.matmul()&lt;/code&gt;, ou bien avec l'opérateur &lt;code&gt;@&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(a @ b) # np.matmul(a, b)
# [[19 22]
# [43 50]]
&lt;/syntaxhighlight&gt;
Pour un poduit scalaire :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([1, 2, 3])
B = np.array([4, 5, 6])
# 32
&lt;/syntaxhighlight&gt;

Notez que :
* pour le produit par un scalaire, les fonctions &lt;code lang=&quot;python&quot;&gt;np.multiply()&lt;/code&gt; et l'opérateur &lt;code lang=&quot;python&quot;&gt;*&lt;/code&gt; sont plus performants ;
* la fonction &lt;code lang=&quot;python&quot;&gt;np.dot()&lt;/code&gt; est plus performante pour le produit scalaire de deux vecteurs réels ;
* lorsque l'on a des vecteurs complexes, la fonction &lt;code lang=&quot;python&quot;&gt;np.vdot()&lt;/code&gt; fait le produit par le conjugué du premier membre (&lt;code lang=&quot;python&quot;&gt;np.vdot(a, b) == np.dot(a.conj(), b)&lt;/code&gt;) ;
* la fonction &lt;code lang=&quot;python&quot;&gt;np.matmul()&lt;/code&gt; et l'opérateur &lt;code lang=&quot;python&quot;&gt;@&lt;/code&gt; (&lt;code lang=&quot;python&quot;&gt;A @ B&lt;/code&gt;) sont plus performants pour un produit matriciel.
L'opérateur &lt;code&gt;@=&lt;/code&gt; fait un produit matriciel en modifiant la variable elle-même (à l'image de &lt;code&gt;*=&lt;/code&gt; pour les nombres).

== Calcul vectorisé ==

Les fonctions de NumPy traitent en général les matrices en entier. Ainsi, il n'est pas nécessaire de créer une boucle pour faire défiler les indices un par un. Il en résulte un code clair et compact et surtout un plus grande rapidité d'exécution. Par exemple :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2*np.pi, 50) # 50 points entre 0 et 2π
y = np.sin(x)
plt.plot(x, y)
&lt;/syntaxhighlight&gt;
La variable &lt;code&gt;x&lt;/code&gt; est un vecteur de 50 valeurs et il est traité en une seule passe par la fonction sinus &lt;code&gt;np.sin()&lt;/code&gt;.

Outre le tranchage ''({{lang|en|slicing}})'', on peut utiliser deux autres méthodes pour extraire certaines valeurs d'une matrice :
* utiliser un vecteur ou une matrice d'indices, Python extrait alors les valeurs correspondant aux indices ;
* utiliser un vecteur ou une matrice de booléens de même dimension que a matrice ; Python extrait alors les valeurs correspondant aux &lt;code&gt;True&lt;/code&gt;, la matrice booléenne est un « masque » pour la matrice d'origine. Par exemple : 

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.arange(0, 10)
b = np.array([1, 3, 5, 7, 9])
c = np.array([True, True, False, False, True, False, True, False, False, True])
print(a[b], &quot;\n&quot;, a[c])
&lt;/syntaxhighlight&gt;

Si l'on veut inverser tous les éléments d'une matrice de bolléens, il faut utiliser la fonction &lt;code&gt;np.logical_not()&lt;/code&gt;

'''Exercice'''
 
Écrire un programme Python mettant en œuvre le [[w:crible d'Érathostène|crible d'Érathostène]] pour trouver les nombres premiers inférieurs à une valeur donnée.

{{boîte déroulante début|Solution}}
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/env python
# coding: utf-8

import numpy as np
import matplotlib.pyplot as plt

# ***************
# ***************
# ** Fonctions **
# ***************
# ***************

def eratosthene(limite):
    # Détermine la liste des nombres premiers entre 1 et N
    #     par le crible d'Ératosthène
    # Entrées : limite : nombre entier, N
    # Sorties : liste : vecteur d'entiers,liste des nombres premiers
    
    indices = (np.ones(limite) == 1) # vecteur de booléens tous à True
    # à la fin, indice(i-1) est True si i est premier, False sinon
    indices[0]=False # 1 n'est pas premier
    imax = int(limite)
    i = 2 # initialisation
    repete = (i &lt;= imax)
    while repete:
        if indices[i-1]:
            jmax = int(limite/i)
            j = np.arange(1, jmax)+1
            indices[i*j-1]=False # élimination des multiples de i
            test = (i*jmax == imax)
        i = i + 1
        repete = i*i &lt; limite # condition d'arrêt
    liste0 = np.arange(limite)
    liste = liste0[indices]+1
    return liste

# *************************
# *************************
# ** Programme principal **
# *************************
# *************************

print(&quot;***** Recherche de nombres premiers par le crible d'Ératosthène *****\n&quot;)

nmax = eval(input(&quot;Entrez la valeur maximale : &quot;))
resultat = eratosthene(nmax)

print(&quot;\n&quot;, resultat.shape[0], &quot;nombres premiers entre 1 et&quot;, nmax, &quot;:\n&quot;)
print(resultat)

plt.plot(resultat, np.zeros_like(resultat), &quot;|&quot;)
&lt;/syntaxhighlight&gt;

L'extraction par un vecteur d'indice intervient dans l'instruction :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
indices[i*j-1]=False
&lt;/syntaxhighlight&gt;
qui élimine en une seule passe tous les multiples de ''i''. L'extraction par un vecteur booléen intervient dans l'instruction :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
liste = liste0[indices]+1
&lt;/syntaxhighlight&gt;
qui permet d'extraire toutes la valeurs conservées en une seule passe.
{{boîte déroulante fin}}

== Attributs ==

La classe &lt;code&gt;ndarray&lt;/code&gt;, qui définit les matrices, possède un certain nombre d'attributs :
* &lt;code&gt;.shape&lt;/code&gt; : dimensions de la matrice ;
* &lt;code&gt;.ndim&lt;/code&gt; : ordre du tenseur ; 
* &lt;code&gt;.size&lt;/code&gt; : nombre d'éléments ;
* &lt;code&gt;.dtype&lt;/code&gt; : type des éléments.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.linspace(1, 9, 9)
print(&quot;a&quot;, a, &quot;\n&quot;,
    &quot; ; shape :&quot;, a.shape,
    &quot; ; dim : &quot;, a.ndim,
    &quot; ; size : &quot;, a.size,
    &quot; ; dtype : &quot;, a.dtype, &quot;\n&quot;)
&lt;/syntaxhighlight&gt;
* &lt;code&gt;.real&lt;/code&gt;, &lt;code&gt;.imag&lt;/code&gt; : parties réelle et imaginaire de la matrice ;
* &lt;code&gt;.flat&lt;/code&gt; : liste des éléments de la matrice ; les éléments sont réorganisés en une liste ;
* &lt;code&gt;.T&lt;/code&gt; : transposée.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;a = np.arange(0, 9).reshape(3, 3)
print(a)
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]] 
print(a.T)
# [[0 3 6]
#  [1 4 7]
#  [2 5 8]] 
print(a.flat[:])
# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
&lt;/syntaxhighlight&gt;
; Ressources
: Section « Attribute », {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
 | titre = numpy.ndarray
 | site = Numpy and Scipy Documentation
 | consulté le = 2019-03-16
}}

== Fonctions et méthodes de base ==

La classe &lt;code&gt;ndarray&lt;/code&gt; possède un certain nombre de méthodes :
* &lt;code&gt;.min()&lt;/code&gt; et &lt;code&gt;.max()&lt;/code&gt; : valeurs respectivement minimale et maximale ;
* &lt;code&gt;.ptp()&lt;/code&gt; : amplitude « max – min » ''({{lang|en|peak to peak}})'' ;
* &lt;code&gt;.argmin()&lt;/code&gt; et &lt;code&gt;argmax()&lt;/code&gt; : indice où se trouvent les valeurs respectivement minimale et maximale ;
* &lt;code&gt;.sum()&lt;/code&gt;, &lt;code&gt;prod()&lt;/code&gt; : somme et produit de tous les éléments de la matrice ;
* &lt;code&gt;.cumsum()&lt;/code&gt;, &lt;code&gt;cumprod()&lt;/code&gt; : somme et produit cumulés.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.linspace(1, 9, 9)
print(&quot;min : &quot;, a.min(),
    &quot;; max : &quot;, a.max(), &quot;\n&quot;,
    &quot;sum : &quot;, a.sum(),
    &quot;; cumsum : &quot;, a.cumsum(), &quot;\n&quot;,
    &quot;prod : &quot;, a.prod(),
    &quot;; cumprod : &quot;, a.cumprod(), &quot;\n&quot;)
&lt;/syntaxhighlight&gt;

Méthodes statistiques :
* &lt;code&gt;.mean()&lt;/code&gt; : moyenne ;
* &lt;code&gt;.std()&lt;/code&gt; : écart type ''({{lang|en|standard deviation}})''.
{{loupe|../Statistiques}}

Extraction de données :
* &lt;code&gt;.diagonal()&lt;/code&gt; : vecteur contenant les éléments de la diagonale ;
* &lt;code&gt;.flatten()&lt;/code&gt; : matrice « aplatie », c'est-à-dire vecteur contenant les éléments réorganisés en liste ; par rapport à l'attribut &lt;code&gt;.flat&lt;/code&gt;, on peut choisir le sens de linéarisation (par lignes, &lt;code&gt;.flatten(C)&lt;/code&gt;, ou par colonnes, &lt;code&gt;.flatten(F)&lt;/code&gt;) mais cela crée une copie, on ne peut pas par exemple s'en servir pour modifier la matrice ;
* &lt;code&gt;.tofile()&lt;/code&gt; : crée un fichier texte contenant les valeurs de la matrice ; par exemple, pour une matrice &lt;code&gt;a&lt;/code&gt; et pour séparer les valeurs par un point-virgule :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.tofile(&quot;matriceA.txt&quot;, sep=&quot; ; &quot;)
&lt;/syntaxhighlight&gt;
* &lt;code&gt;.astype(''type'')&lt;/code&gt; : copie la matrice en convertissant le type de données :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a.astype(float) # pour avoir une matrice de réels en virgule flottante
a = a.astype(str) # pour avoir une matrice de chaînes de caractères
&lt;/syntaxhighlight&gt;

Tri :
* &lt;code&gt;np.sort(M, i)&lt;/code&gt; : crée une copie et trie la matrice selon l'axe ''i'' (0 pour le premier indice, 1 pour le deuxième… la valeur par défaut est –1 pour le dernier indice, la valeur ''none'' aplatit la matrice) ; &lt;code&gt;np.sort(M, 0)&lt;/code&gt; trie chaque colonne indépendamment par ordre croissant, &lt;code&gt;np.sort(M, 1)&lt;/code&gt; trie chaque ligne indépendamment par ordre croissant ;
* &lt;code&gt;M.sort(i)&lt;/code&gt; : cette méthode trie la matrice en elle-même ;
* &lt;code&gt;np.argsort(M, i)&lt;/code&gt; : crée une matrice contenant le nouvel indice, selon l'axe ''i'', de chaque élément.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5]])
M.sort(1) # tri des lignes indépendamment -&gt; [[1, 5, 5, 7], [2, 3, 4, 9], [1, 5, 7, 9]]
&lt;/syntaxhighlight&gt;
Pour trier les lignes selon la deuxième colonne d'une matrice, tout en conservant les lignes intactes, on peut faire comme suit :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5]])
ind = np.argsort(M[:, 1]) # indices de tri selon la 2e colonne
N = M[ind, :] # réarrangement des lignes -&gt; [[9, *1*, 7, 5], [1, *5*, 7, 5], [2, *9*, 4, 3]]
&lt;/syntaxhighlight&gt;
Pour faire un tri lexicographique, on utilise la fonction &lt;code&gt;np.lexsort()&lt;/code&gt; en indiquant les différentes colonnes :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5], [2, 9, 8, 5]])
ind = np.lexsort((M[:, 3], M[:, 2], M[:, 1], M[:, 0])) # indices de tri selon la 1re, puis la 2e, puis la 3e, puis la 4e colonne
N = M[ind, :] # réarrangement des lignes -&gt; [[1, 5, 7, 5], [2, 9, 4, 3], [2, 9, 8, 5], [9, 1, 7, 5]]
&lt;/syntaxhighlight&gt;
Le tri se fait par ordre croissant. Pour trier par ordre décroissant, on inverse l'ordre de la matrice en faisant une extraction avec un pas de moins un, par exemple pour inverser les lignes :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = M[:, ::-1]
&lt;/syntaxhighlight&gt;

Algèbre linéaire :
* &lt;code&gt;a.dot(b)&lt;/code&gt; : produit matriciel ''a''⋅''b'' ; on peut aussi écrire &lt;code&gt;a@b&lt;/code&gt; ;
* &lt;code&gt;.trace()&lt;/code&gt; : trace de la matrice (somme des éléments diagonaux) ;
* &lt;code&gt;.transpose()&lt;/code&gt; : transpose la matrice, résultat similaire à l'attribut &lt;code&gt;.T&lt;/code&gt; ;
* &lt;code&gt;np.cross()&lt;/code&gt; : produit vectoriel dans ℝ³.
{{loupe|../Algèbre linéaire}}

Matrices de booléens :
* &lt;code&gt;.all()&lt;/code&gt; : applique un « et » logique à toutes les valeurs de la matrice ;
* &lt;code&gt;.any()&lt;/code&gt; : applique un « ou » logique à toutes les valeurs de la matrice.
{{loupe|../Fonctions mathématiques générales#Fonctions booléennes}}

Autre méthodes :
* &lt;code&gt;.conj()&lt;/code&gt; : conjugué des valeurs complexes ;
* &lt;code&gt;.nonzero()&lt;/code&gt; : n-uplet contenant les indices des valeurs non-nulles ;
* &lt;code&gt;.round(n)&lt;/code&gt; : arrondit les valeurs à la ''n''-ième décimale.

; Ressources
: Section « Method », {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
 | titre = numpy.ndarray
 | site = Numpy and Scipy Documentation
 | consulté le = 2019-03-16
}}

== Propagation ==

Le terme « propagation » ''({{lang|en|broadcasting}})'' désigne la manière dont Python complète les matrice lorsque des dimensions manquent. 

Supposons que l'on veuille additionner deux matrices M&lt;sub&gt;1&lt;/sub&gt; et M&lt;sub&gt;2&lt;/sub&gt; de dimensions ''m''&lt;sub&gt;1&lt;/sub&gt; × ''n''&lt;sub&gt;1&lt;/sub&gt; et ''m''&lt;sub&gt;2&lt;/sub&gt; × ''n''&lt;sub&gt;2&lt;/sub&gt; différentes. Alors :
* le résultat a pour dimension max(''m''&lt;sub&gt;1&lt;/sub&gt;, ''m''&lt;sub&gt;2&lt;/sub&gt;) × max(''n''&lt;sub&gt;1&lt;/sub&gt;, ''n''&lt;sub&gt;2&lt;/sub&gt;) ;
* si une des dimensions vaut 1, alors les valeurs de l'autre dimension sont dupliquées ;
* sinon, les dimensions manquantes pour chaque matrice sont complétées par des 1.
Par exemple :
: &lt;math&gt;\mathrm{A} = \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
: &lt;math&gt;5 + \mathrm{A} = \begin{pmatrix} 5 &amp; 5 \\ 5 &amp; 5 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
:: La matrice (5) est de dimension 1 × 1, la valeur « 5 » est donc répétée dans les deux dimensions
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
print(5 + A)
# [[6 7]
#  [7 8]]
&lt;/syntaxhighlight&gt;
: &lt;math&gt;(5, 4) + \mathrm{A} = \begin{pmatrix} 5 &amp; 4 \\ 5 &amp; 4 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(np.array([[5, 4]]) + A)
# [[6 6]
#  [6 8]]
&lt;/syntaxhighlight&gt;
: &lt;math&gt;\begin{pmatrix} 5 \\ 4 \end{pmatrix} + \mathrm{A} = \begin{pmatrix} 5 &amp; 5 \\ 4 &amp; 4 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(np.array([[5], [4]]) + A)
# [[6 7]
#  [7 8]]
&lt;/syntaxhighlight&gt;

== Fonctions « universelles » ==

Les fonctions universelles ''({{lang|en|ufunc}})'' sont les fonctions s'appliquant aux matrices, des fonctions vectorisées.

; Ressource
: {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs
 | titre = Available ufuncs
 | site = SciPy documentation
 | consulté le = 2019-03-21
}}

== Algèbre linéaire ==
{{loupe|../Algèbre linéaire}}

== Notes et références ==
{{références}}

----
[[../Graphiques|Graphiques]] &amp;lt; [[../|↑]] &amp;gt; [[../Polynômes|Polynômes]]

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>r21iyanvz2zwkcmec3wogltj0x2o13m</sha1>
    </revision>
    <revision>
      <id>769249</id>
      <parentid>769248</parentid>
      <timestamp>2026-06-30T12:22:32Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Trouver une valeur */ précisions</comment>
      <origin>769249</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="26370" sha1="hot9mb7nmlybpxy1itpp2c1j6uc0mus" xml:space="preserve">Les matrices sont un élément primordial du calcul scientifique sur ordinateur pour deux raisons :
# L'algèbre linéaire est au cœur de nombreux calculs.
# Les matrices sont l'élément de base du calcul vectorisé qui permet un gain de temps appréciable.
Pour pouvoir expliter les matrices, il faut charger le module NumPy ; nous utilisons également Matplotlib pour les graphiques. Ainsi, les programmes contiennent tous au début :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;

== Rappels et complément sur le tranchage ==
Soit une liste L composée de ''n'' éléments.
* Les éléments sont numérotés de 0 à ''n'' – 1.
* Le premier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[0]&lt;/code&gt;.
* Le i-ème élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[''i'' - 1]&lt;/code&gt;.
* L'avant-dernier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[-2]&lt;/code&gt;.
* Le dernier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[-1]&lt;/code&gt;.
* La sous-liste composée des éléments contigus ''i'' à ''j'' s'obtient par &lt;code lang=&quot;python&quot;&gt;L[''i'' - 1:j]&lt;/code&gt;.
Ainsi, &lt;code lang=&quot;python&quot;&gt;L[0:1]&lt;/code&gt; va extraire le premier élément, &lt;code lang=&quot;python&quot;&gt;L[1:-1]&lt;/code&gt; va extraire tous les éléments sauf le premier et le dernier.

{{voir|[[Python_pour_le_calcul_scientifique/Découverte_de_Python_et_de_Jupyter#Itérable|Découverte_de_Python_et_de_Jupyter &amp;gt; Itérable]]}}

NumPy fournit des fonctions permettant de manipuler les matrices :
* &lt;code lang=&quot;python&quot;&gt;np.append(A, B)&lt;/code&gt; : fusionne les vecteurs A et B ;&lt;br /&gt; s'il s'agit de matrices ou de tenseurs, la fonction les « aplatit », les transforme en vecteur ;&lt;br /&gt;si l'on veut intégrer B dans A, on utilise &lt;code lang=&quot;python&quot;&gt;A = np.append(A, B)&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.append(A, B, axis = ''i'')&lt;/code&gt; : fusionne les tenseurs selon l'indice ''i'' (&lt;code&gt;0&lt;/code&gt; pour le premier indice, &lt;code&gt;1&lt;/code&gt; pour le deuxième…) ;
* &lt;code lang=&quot;python&quot;&gt;np.insert(A, i, m)&lt;/code&gt; : insère le vecteur ''m'' dans le vecteur A (ou la matrice A aplatie) à l'emplacement ''i'' ;
* &lt;code lang=&quot;python&quot;&gt;np.insert(A, i, M, axis = ''j'')&lt;/code&gt; : insère le tenseur M dans le tenseur A à l'emplacement ''i'' de l'indice ''j'' ;
* &lt;code lang=&quot;python&quot;&gt;np.delete(A, I)&lt;/code&gt; : efface les éléments définis par le tranchage I du vecteur A (ou de la matrice A aplatie) ;
* &lt;code lang=&quot;python&quot;&gt;np.delete(A, I, axis = ''j'')&lt;/code&gt; : efface les éléments définis par le tranchage I selon l'indice ''j'' du tenseur A.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1]])
B = np.array([[2, 3, 4]])
C = np.append(A, B, axis=1)
print(A, B, C, sep=&quot;\n&quot;)
# [[1]]
# [[2 3 4]]
# [[1 2 3 4]]
D = np.array([[10, 20, 30, 40]])
E = np.append(C, D, axis=0)
print(E)
# [[ 1  2  3  4]
#  [10 20 30 40]]
&lt;/syntaxhighlight&gt;
On peut utiliser &lt;code&gt;np.r_[A, B]&lt;/code&gt; pour concaténer A et B en ligne ''(row), et &lt;code&gt;np.c_[A, B]&lt;/code&gt; pour les concaténer en colonne.

On peut extraire une sous-matrice à partir d'une matrice de booléens :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1, 2], [3, 4], [5, 6]])
booleen = np.logical_or(A==1, A==3)
print(booleen)
# [[ True False]
#  [ True False]
#  [ False False]]
print(A[booleen])
# [1 3]

booleen = np.logical_or(A[:, 0]==1, A[:, 0]==3)
print(booleen)
# [ True  True False]
print(A[booleen])
# [[1 2]
#  [3 4]]
print(A[booleen][:, 1])
# [2 4]
&lt;/syntaxhighlight&gt;

== Différence entre ''array'' et ''matrix'' ==
Il existe deux types d'objet NumPy pour décrire les matrices : les objets ''array'' (tableau, classe &lt;code&gt;ndarray&lt;/code&gt;) et les objets ''matrix'' (matrice, classe &lt;code&gt;matrix&lt;/code&gt;).
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1, 2], [3, 4], [5, 6]])
B = np.matrix([[1, 2], [3, 4], [5, 6]])
&lt;/syntaxhighlight&gt;
Il y a trois différences :
* les objets ''array'' peuvent être de n'importe quelle dimension : 0 (scalaire), 1 (vecteur), 2 (matrice), 3 (tenseur d'ordre 3)… alors qu'un objet ''matrix'' est nécessairement de dimension 2 ;
* les opération sur les objets ''matrix'' sont par défaut des opérations matricielles ; ainsi, la multiplication &lt;code&gt;A * B&lt;/code&gt; va être une multiplication terme à terme si A et B sont des ''array'', et une multiplication matricielle si A et B sont des ''matrix'' ; pour avoir la multiplication matricielle entre ''array'', il faut utiliser &lt;code&gt;a@b&lt;/code&gt; ou &lt;code&gt;np.dot(a,b)&lt;/code&gt; ;
* si une matrice A est inversible, alors avec un objet ''matrix'', on peut utiliser la méthode &lt;code&gt;A.I&lt;/code&gt; ; si A est un objet ''array'', il faut utiliser &lt;code&gt;np.linalg.inv(A)&lt;/code&gt;.

La classe &lt;code&gt;matrix&lt;/code&gt; a été dépréciée, il est recommandé de n'utiliser que la classe &lt;code&gt;ndarray&lt;/code&gt;. Nous n'utiliserons donc pas la classe &lt;code&gt;matrix&lt;/code&gt;.

== Définir un tenseur ==
Un tenseur est similaire à une liste mais il est défini par la fonction &lt;code&gt;np.array()&lt;/code&gt;. La définition et l'extraction de composante utilise la méthode du découpage en tranches ''({{lang|en|slicing}})''.

'''Exemples'''
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 3, 5, 7]) # vecteur
bc = np.array([[1], [2], [3], [4]]) # matrice 4 × 1 (matrice colonne)
bl = np.array([[1, 2, 3, 4]]) # matrice 1 × 4 (matrice ligne)
c = np.array([[1, 2, 3],
              [2, 3, 4],
              [3, 4, 5]]) # matrice 3 × 3
d = np.array([[[1,  2, 3],
               [2,  3, 4]],
              [[10, 9, 8],
               [ 7, 6, 5]]]) # tenseur d'ordre 3, de dimension 3 × 2 × 2
                       
&lt;/syntaxhighlight&gt;
Notez que dans NumPy, un vecteur n'est pas la même chose qu'une matrice ligne ou colonne. Un vecteur de dimension ''n'' est un tenseur d'ordre 1 et de dimension ''n'' ; une matrice ligne ou colonne est un tenseur d'ordre 2 et de dimension 1 × ''n'' ou ''n'' × 1.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 2, 3])
b = np.array([[1, 2, 3]])
c = np.array([[1], [2], [3]])
print(a.size, b.size, c.size) # 3 3 3
print(a.ndim, b.ndim, c.ndim) # 1 2 2
print(a.shape, b.shape, c.shape) # (3,) (1, 3) (3, 1)
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; est similaire à la fonction &lt;code&gt;range()&lt;/code&gt; pour les liste ; elle génère un vecteur de réels. La fonction &lt;code&gt;np.linspace()&lt;/code&gt; permet également de créer un vecteur de même type, mais on indique le dernier nombre alors que la règle du découpage en tranches fait que le nombre maximal indiqué à &lt;code&gt;np.arange()&lt;/code&gt; est le premier nombre qui ne ''figure pas'' dans le vecteur.). La fonction &lt;code&gt;np.zeros()&lt;/code&gt; génère une matrice nulle, &lt;code&gt;np.zeros_like()&lt;/code&gt; une matrice nulle ayant les dimensions d'une matrice fournie comme modèle. De même, &lt;code&gt;np.ones()&lt;/code&gt; et &lt;code&gt;np.ones_like()&lt;/code&gt; crée des matrices, dont toutes les composantes sont à 1. La fonction &lt;code&gt;np.eye()&lt;/code&gt; crée une matrice unité.

'''Exemples'''
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
e = np.arange(0, 2, 0.1) # vecteur [0, 0.1, 0.2…, 1.8, 1.9]
f = np.linspace(0, 2, 5) # 5 nombres entre 0 et 2 soit le vecteur [0, 0.5, 1, 1.5, 2]
g = np.zeros(3) # vecteur nul de dimension 3
h = np.zeros((3, 3)) # matrice nulle 3 × 3
k = np.ones_like(a) # matrice de 1 de même dimension que a 
u = np.eye(3) # matrice unité 3 × 3                  
&lt;/syntaxhighlight&gt;
Le paramètre &lt;code&gt;dtype&lt;/code&gt; permet de forcer le type. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 2, 3], dtype=&quot;complex&quot;)
k = np.ones_like(a, dtype=&quot;int&quot;)
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;np.linspace()&lt;/code&gt; peut créer des matrices colonne : on donne la première et la dernière ligne ; par exemple : :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
np.linspace([1, -1], [10, -10], 4)
# [[  1.  -1.]
#  [  4.  -4.]
#  [  7.  -7.]
#  [ 10. -10.]]
&lt;/syntaxhighlight&gt;
Les commandes &lt;code&gt;np.geomspace()&lt;/code&gt; et &lt;code&gt;np.geomspace()&lt;/code&gt; fonctionnent comme &lt;code&gt;np.linspace()&lt;/code&gt;, mais avec une progression logarithmique. La commande &lt;code&gt;np.geomspace(a, b, n)&lt;/code&gt; crée un vecteur (ou une matrice colonne) allant de ''a'' à ''b'' alors que &lt;code&gt;np.logspace(a, b, n)&lt;/code&gt; crée un vecteur (ou une matrice colonne) allant de 10&lt;sup&gt;''a''&lt;/sup&gt; à 10&lt;sup&gt;''b''&lt;/sup&gt;.

La méthode &lt;code&gt;.reshape()&lt;/code&gt; remet en forme une matrice. Par exemple, pour transformer un vecteur de dimension 9 en une matrice 3 × 3 :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.arange(1, 10)
b = a.reshape(3, 3)
# ou bien directement
c = np.arange(1, 10).reshape(3, 3)         
&lt;/syntaxhighlight&gt;
Avec la méthode &lt;code&gt;.reshape()&lt;/code&gt;, on peut utiliser la valeur –1 pour une des dimensions ; sa valeur est alors automatiquement calculée en fonction du nombre d'éléments et de l'autre dimension. On peut aussi utiliser une dimension vide ; cela crée alors un vecteur. Par exemple, pour une matrice M quelconque :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M.reshape(-1, 1) # crée une matrice colonne
M.reshape(1, -1) # crée une matrice ligne
M.reshape(-1,) # crée un vecteur
&lt;/syntaxhighlight&gt;


La méthode &lt;code&gt;.fill()&lt;/code&gt; remplit la matrice avec un scalaire :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b.fill(5) # remplace les valeurs de b par la valeur 5
&lt;/syntaxhighlight&gt;

== Extraction matricielle ==
Si l'on veut extraire les colonnes 1 et 3 pour toutes les lignes d'une matrice M, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M[:, [0, 2]]
&lt;/syntaxhighlight&gt;

== Trouver une valeur ==
Pour trouver une valeur, on utilise la fonction &lt;code&gt;where()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
print(A)
# [[1 2]
#  [3 4]]
B = np.where(A == 3)
print(B)
# (array([1]), array([0])
print(B[0][0], B[1][0])
# 1 0
C = np.where(A == 5)
print(C)
# (array([], dtype=int64), array([], dtype=int64))
# C est un n-uplet (tuple) contenant deux vecteurs d'entiers vides.
print(len(C[0])) # taille du premier vecteur du n-uplet C
# 0
&lt;/syntaxhighlight&gt;
Notez que &lt;code&gt;where()&lt;/code&gt; peut servir à construire une matrice à partir de deux autres matrices selon une condition. Par exemple, pour comparer les éléments deux à deux et sélectionner le plus grand :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
B = np.array([[0, 1], [4, 5]])
C = np.where(A &gt; B, A, B)
print(C)
# [[1 2]
#  [4 5]
&lt;/syntaxhighlight&gt;
La syntaxyte générale est &lt;code&gt;C = np.where(condition, A, B)&lt;/code&gt; où &lt;condition&lt;/code&gt; est une matrice de booléens ; pour un indice (''i'', ''j''), si &lt;code&gt;condition[i, j]&lt;/code&gt; est vrai, alors &lt;code&gt;C[i, j]&lt;/code&gt; vaut &lt;code&gt;A[i, j]&lt;/code&gt;, sinon elle vaut &lt;code&gt;B[i, j]&lt;/code&gt;.

== Assemblage de matrices ==
Si l'on veut regrouper deux matrices, on utilise la commande &lt;code&gt;np.concatenate()&lt;/code&gt;. On utilise le paramètre ''axis'' pour indiquer si l'on empile les matrices l'une au-dessus de l'autre (&lt;code&gt;axis=0&lt;/code&gt;) ou bien l'une derrière l'autre (&lt;code&gt;axis=1&lt;/code&gt;). Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1 ,2], [3, 4]])
B = np.array([[5 ,6], [7, 8]])
C = np.concatenate((A, B), axis = 0)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]
D = np.concatenate((A, B), axis = 1)
# [[1 2 5 6]
#  [3 4 7 8]]
&lt;/syntaxhighlight&gt;
Si l'on veut transformer deux vecteurs en une matrice de deux colonnes, chaque vecteur occupant une colonne :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([1 ,2])
B = np.array([3 ,4])
C = np.concatenate((A.reshape(-1, 1), B.reshape(-1, 1)), axis = 1)
# [[1 3]
#  [2 4]]
&lt;/syntaxhighlight&gt;

== Opérations matricielles ==

Les quatre opérations classiques &lt;code lang=&quot;python&gt;+&lt;/code&gt;, &lt;code lang=&quot;python&gt;-&lt;/code&gt; et &lt;code lang=&quot;python&gt;/&lt;/code&gt; ne fonctionnent qu'entre tenseurs de mêmes dimensions et sont des opérations élément par élément ''({{lang|en|elementwise operations}})'' :
* &lt;code lang=&quot;python&quot;&gt;(A + B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] + B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;(A - B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] - B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;(A / B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] / B[i, j, k]&lt;/code&gt;.
La multiplication élément par élément se fait avec
: &lt;code lang=&quot;python&quot;&gt;np.multiply(A, B)&lt;/code&gt; qui vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] * B[i, j, k]&lt;/code&gt;.
De même, les fonctions &lt;code lang=&quot;python&gt;np.add()&lt;/code&gt;, &lt;code lang=&quot;python&gt;np.subtract()&lt;/code&gt;, &lt;code lang=&quot;python&gt;np.multiply()&lt;/code&gt; et &lt;code lang=&quot;python&gt;np.divide()&lt;/code&gt; effectuent des opérations élément par élément sur des tenseurs de mêmes dimensions :
* &lt;code lang=&quot;python&quot;&gt;np.add(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] + B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.subtract(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] - B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.multiply(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] * B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.divide(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] / B[i, j, k]&lt;/code&gt;.
La multiplication matricielle, au sens de l'algèbre linéaire, se fait avec les fonctions &lt;code lang=&quot;python&quot;&gt;np.dot()&lt;/code&gt; ou &lt;code lang=&quot;python&quot;&gt;np.matmul()&lt;/code&gt;, ou bien avec l'opérateur &lt;code&gt;@&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(a @ b) # np.matmul(a, b)
# [[19 22]
# [43 50]]
&lt;/syntaxhighlight&gt;
Pour un poduit scalaire :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([1, 2, 3])
B = np.array([4, 5, 6])
# 32
&lt;/syntaxhighlight&gt;

Notez que :
* pour le produit par un scalaire, les fonctions &lt;code lang=&quot;python&quot;&gt;np.multiply()&lt;/code&gt; et l'opérateur &lt;code lang=&quot;python&quot;&gt;*&lt;/code&gt; sont plus performants ;
* la fonction &lt;code lang=&quot;python&quot;&gt;np.dot()&lt;/code&gt; est plus performante pour le produit scalaire de deux vecteurs réels ;
* lorsque l'on a des vecteurs complexes, la fonction &lt;code lang=&quot;python&quot;&gt;np.vdot()&lt;/code&gt; fait le produit par le conjugué du premier membre (&lt;code lang=&quot;python&quot;&gt;np.vdot(a, b) == np.dot(a.conj(), b)&lt;/code&gt;) ;
* la fonction &lt;code lang=&quot;python&quot;&gt;np.matmul()&lt;/code&gt; et l'opérateur &lt;code lang=&quot;python&quot;&gt;@&lt;/code&gt; (&lt;code lang=&quot;python&quot;&gt;A @ B&lt;/code&gt;) sont plus performants pour un produit matriciel.
L'opérateur &lt;code&gt;@=&lt;/code&gt; fait un produit matriciel en modifiant la variable elle-même (à l'image de &lt;code&gt;*=&lt;/code&gt; pour les nombres).

== Calcul vectorisé ==

Les fonctions de NumPy traitent en général les matrices en entier. Ainsi, il n'est pas nécessaire de créer une boucle pour faire défiler les indices un par un. Il en résulte un code clair et compact et surtout un plus grande rapidité d'exécution. Par exemple :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2*np.pi, 50) # 50 points entre 0 et 2π
y = np.sin(x)
plt.plot(x, y)
&lt;/syntaxhighlight&gt;
La variable &lt;code&gt;x&lt;/code&gt; est un vecteur de 50 valeurs et il est traité en une seule passe par la fonction sinus &lt;code&gt;np.sin()&lt;/code&gt;.

Outre le tranchage ''({{lang|en|slicing}})'', on peut utiliser deux autres méthodes pour extraire certaines valeurs d'une matrice :
* utiliser un vecteur ou une matrice d'indices, Python extrait alors les valeurs correspondant aux indices ;
* utiliser un vecteur ou une matrice de booléens de même dimension que a matrice ; Python extrait alors les valeurs correspondant aux &lt;code&gt;True&lt;/code&gt;, la matrice booléenne est un « masque » pour la matrice d'origine. Par exemple : 

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.arange(0, 10)
b = np.array([1, 3, 5, 7, 9])
c = np.array([True, True, False, False, True, False, True, False, False, True])
print(a[b], &quot;\n&quot;, a[c])
&lt;/syntaxhighlight&gt;

Si l'on veut inverser tous les éléments d'une matrice de bolléens, il faut utiliser la fonction &lt;code&gt;np.logical_not()&lt;/code&gt;

'''Exercice'''
 
Écrire un programme Python mettant en œuvre le [[w:crible d'Érathostène|crible d'Érathostène]] pour trouver les nombres premiers inférieurs à une valeur donnée.

{{boîte déroulante début|Solution}}
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/env python
# coding: utf-8

import numpy as np
import matplotlib.pyplot as plt

# ***************
# ***************
# ** Fonctions **
# ***************
# ***************

def eratosthene(limite):
    # Détermine la liste des nombres premiers entre 1 et N
    #     par le crible d'Ératosthène
    # Entrées : limite : nombre entier, N
    # Sorties : liste : vecteur d'entiers,liste des nombres premiers
    
    indices = (np.ones(limite) == 1) # vecteur de booléens tous à True
    # à la fin, indice(i-1) est True si i est premier, False sinon
    indices[0]=False # 1 n'est pas premier
    imax = int(limite)
    i = 2 # initialisation
    repete = (i &lt;= imax)
    while repete:
        if indices[i-1]:
            jmax = int(limite/i)
            j = np.arange(1, jmax)+1
            indices[i*j-1]=False # élimination des multiples de i
            test = (i*jmax == imax)
        i = i + 1
        repete = i*i &lt; limite # condition d'arrêt
    liste0 = np.arange(limite)
    liste = liste0[indices]+1
    return liste

# *************************
# *************************
# ** Programme principal **
# *************************
# *************************

print(&quot;***** Recherche de nombres premiers par le crible d'Ératosthène *****\n&quot;)

nmax = eval(input(&quot;Entrez la valeur maximale : &quot;))
resultat = eratosthene(nmax)

print(&quot;\n&quot;, resultat.shape[0], &quot;nombres premiers entre 1 et&quot;, nmax, &quot;:\n&quot;)
print(resultat)

plt.plot(resultat, np.zeros_like(resultat), &quot;|&quot;)
&lt;/syntaxhighlight&gt;

L'extraction par un vecteur d'indice intervient dans l'instruction :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
indices[i*j-1]=False
&lt;/syntaxhighlight&gt;
qui élimine en une seule passe tous les multiples de ''i''. L'extraction par un vecteur booléen intervient dans l'instruction :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
liste = liste0[indices]+1
&lt;/syntaxhighlight&gt;
qui permet d'extraire toutes la valeurs conservées en une seule passe.
{{boîte déroulante fin}}

== Attributs ==

La classe &lt;code&gt;ndarray&lt;/code&gt;, qui définit les matrices, possède un certain nombre d'attributs :
* &lt;code&gt;.shape&lt;/code&gt; : dimensions de la matrice ;
* &lt;code&gt;.ndim&lt;/code&gt; : ordre du tenseur ; 
* &lt;code&gt;.size&lt;/code&gt; : nombre d'éléments ;
* &lt;code&gt;.dtype&lt;/code&gt; : type des éléments.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.linspace(1, 9, 9)
print(&quot;a&quot;, a, &quot;\n&quot;,
    &quot; ; shape :&quot;, a.shape,
    &quot; ; dim : &quot;, a.ndim,
    &quot; ; size : &quot;, a.size,
    &quot; ; dtype : &quot;, a.dtype, &quot;\n&quot;)
&lt;/syntaxhighlight&gt;
* &lt;code&gt;.real&lt;/code&gt;, &lt;code&gt;.imag&lt;/code&gt; : parties réelle et imaginaire de la matrice ;
* &lt;code&gt;.flat&lt;/code&gt; : liste des éléments de la matrice ; les éléments sont réorganisés en une liste ;
* &lt;code&gt;.T&lt;/code&gt; : transposée.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;a = np.arange(0, 9).reshape(3, 3)
print(a)
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]] 
print(a.T)
# [[0 3 6]
#  [1 4 7]
#  [2 5 8]] 
print(a.flat[:])
# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
&lt;/syntaxhighlight&gt;
; Ressources
: Section « Attribute », {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
 | titre = numpy.ndarray
 | site = Numpy and Scipy Documentation
 | consulté le = 2019-03-16
}}

== Fonctions et méthodes de base ==

La classe &lt;code&gt;ndarray&lt;/code&gt; possède un certain nombre de méthodes :
* &lt;code&gt;.min()&lt;/code&gt; et &lt;code&gt;.max()&lt;/code&gt; : valeurs respectivement minimale et maximale ;
* &lt;code&gt;.ptp()&lt;/code&gt; : amplitude « max – min » ''({{lang|en|peak to peak}})'' ;
* &lt;code&gt;.argmin()&lt;/code&gt; et &lt;code&gt;argmax()&lt;/code&gt; : indice où se trouvent les valeurs respectivement minimale et maximale ;
* &lt;code&gt;.sum()&lt;/code&gt;, &lt;code&gt;prod()&lt;/code&gt; : somme et produit de tous les éléments de la matrice ;
* &lt;code&gt;.cumsum()&lt;/code&gt;, &lt;code&gt;cumprod()&lt;/code&gt; : somme et produit cumulés.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.linspace(1, 9, 9)
print(&quot;min : &quot;, a.min(),
    &quot;; max : &quot;, a.max(), &quot;\n&quot;,
    &quot;sum : &quot;, a.sum(),
    &quot;; cumsum : &quot;, a.cumsum(), &quot;\n&quot;,
    &quot;prod : &quot;, a.prod(),
    &quot;; cumprod : &quot;, a.cumprod(), &quot;\n&quot;)
&lt;/syntaxhighlight&gt;

Méthodes statistiques :
* &lt;code&gt;.mean()&lt;/code&gt; : moyenne ;
* &lt;code&gt;.std()&lt;/code&gt; : écart type ''({{lang|en|standard deviation}})''.
{{loupe|../Statistiques}}

Extraction de données :
* &lt;code&gt;.diagonal()&lt;/code&gt; : vecteur contenant les éléments de la diagonale ;
* &lt;code&gt;.flatten()&lt;/code&gt; : matrice « aplatie », c'est-à-dire vecteur contenant les éléments réorganisés en liste ; par rapport à l'attribut &lt;code&gt;.flat&lt;/code&gt;, on peut choisir le sens de linéarisation (par lignes, &lt;code&gt;.flatten(C)&lt;/code&gt;, ou par colonnes, &lt;code&gt;.flatten(F)&lt;/code&gt;) mais cela crée une copie, on ne peut pas par exemple s'en servir pour modifier la matrice ;
* &lt;code&gt;.tofile()&lt;/code&gt; : crée un fichier texte contenant les valeurs de la matrice ; par exemple, pour une matrice &lt;code&gt;a&lt;/code&gt; et pour séparer les valeurs par un point-virgule :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.tofile(&quot;matriceA.txt&quot;, sep=&quot; ; &quot;)
&lt;/syntaxhighlight&gt;
* &lt;code&gt;.astype(''type'')&lt;/code&gt; : copie la matrice en convertissant le type de données :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a.astype(float) # pour avoir une matrice de réels en virgule flottante
a = a.astype(str) # pour avoir une matrice de chaînes de caractères
&lt;/syntaxhighlight&gt;

Tri :
* &lt;code&gt;np.sort(M, i)&lt;/code&gt; : crée une copie et trie la matrice selon l'axe ''i'' (0 pour le premier indice, 1 pour le deuxième… la valeur par défaut est –1 pour le dernier indice, la valeur ''none'' aplatit la matrice) ; &lt;code&gt;np.sort(M, 0)&lt;/code&gt; trie chaque colonne indépendamment par ordre croissant, &lt;code&gt;np.sort(M, 1)&lt;/code&gt; trie chaque ligne indépendamment par ordre croissant ;
* &lt;code&gt;M.sort(i)&lt;/code&gt; : cette méthode trie la matrice en elle-même ;
* &lt;code&gt;np.argsort(M, i)&lt;/code&gt; : crée une matrice contenant le nouvel indice, selon l'axe ''i'', de chaque élément.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5]])
M.sort(1) # tri des lignes indépendamment -&gt; [[1, 5, 5, 7], [2, 3, 4, 9], [1, 5, 7, 9]]
&lt;/syntaxhighlight&gt;
Pour trier les lignes selon la deuxième colonne d'une matrice, tout en conservant les lignes intactes, on peut faire comme suit :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5]])
ind = np.argsort(M[:, 1]) # indices de tri selon la 2e colonne
N = M[ind, :] # réarrangement des lignes -&gt; [[9, *1*, 7, 5], [1, *5*, 7, 5], [2, *9*, 4, 3]]
&lt;/syntaxhighlight&gt;
Pour faire un tri lexicographique, on utilise la fonction &lt;code&gt;np.lexsort()&lt;/code&gt; en indiquant les différentes colonnes :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5], [2, 9, 8, 5]])
ind = np.lexsort((M[:, 3], M[:, 2], M[:, 1], M[:, 0])) # indices de tri selon la 1re, puis la 2e, puis la 3e, puis la 4e colonne
N = M[ind, :] # réarrangement des lignes -&gt; [[1, 5, 7, 5], [2, 9, 4, 3], [2, 9, 8, 5], [9, 1, 7, 5]]
&lt;/syntaxhighlight&gt;
Le tri se fait par ordre croissant. Pour trier par ordre décroissant, on inverse l'ordre de la matrice en faisant une extraction avec un pas de moins un, par exemple pour inverser les lignes :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = M[:, ::-1]
&lt;/syntaxhighlight&gt;

Algèbre linéaire :
* &lt;code&gt;a.dot(b)&lt;/code&gt; : produit matriciel ''a''⋅''b'' ; on peut aussi écrire &lt;code&gt;a@b&lt;/code&gt; ;
* &lt;code&gt;.trace()&lt;/code&gt; : trace de la matrice (somme des éléments diagonaux) ;
* &lt;code&gt;.transpose()&lt;/code&gt; : transpose la matrice, résultat similaire à l'attribut &lt;code&gt;.T&lt;/code&gt; ;
* &lt;code&gt;np.cross()&lt;/code&gt; : produit vectoriel dans ℝ³.
{{loupe|../Algèbre linéaire}}

Matrices de booléens :
* &lt;code&gt;.all()&lt;/code&gt; : applique un « et » logique à toutes les valeurs de la matrice ;
* &lt;code&gt;.any()&lt;/code&gt; : applique un « ou » logique à toutes les valeurs de la matrice.
{{loupe|../Fonctions mathématiques générales#Fonctions booléennes}}

Autre méthodes :
* &lt;code&gt;.conj()&lt;/code&gt; : conjugué des valeurs complexes ;
* &lt;code&gt;.nonzero()&lt;/code&gt; : n-uplet contenant les indices des valeurs non-nulles ;
* &lt;code&gt;.round(n)&lt;/code&gt; : arrondit les valeurs à la ''n''-ième décimale.

; Ressources
: Section « Method », {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
 | titre = numpy.ndarray
 | site = Numpy and Scipy Documentation
 | consulté le = 2019-03-16
}}

== Propagation ==

Le terme « propagation » ''({{lang|en|broadcasting}})'' désigne la manière dont Python complète les matrice lorsque des dimensions manquent. 

Supposons que l'on veuille additionner deux matrices M&lt;sub&gt;1&lt;/sub&gt; et M&lt;sub&gt;2&lt;/sub&gt; de dimensions ''m''&lt;sub&gt;1&lt;/sub&gt; × ''n''&lt;sub&gt;1&lt;/sub&gt; et ''m''&lt;sub&gt;2&lt;/sub&gt; × ''n''&lt;sub&gt;2&lt;/sub&gt; différentes. Alors :
* le résultat a pour dimension max(''m''&lt;sub&gt;1&lt;/sub&gt;, ''m''&lt;sub&gt;2&lt;/sub&gt;) × max(''n''&lt;sub&gt;1&lt;/sub&gt;, ''n''&lt;sub&gt;2&lt;/sub&gt;) ;
* si une des dimensions vaut 1, alors les valeurs de l'autre dimension sont dupliquées ;
* sinon, les dimensions manquantes pour chaque matrice sont complétées par des 1.
Par exemple :
: &lt;math&gt;\mathrm{A} = \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
: &lt;math&gt;5 + \mathrm{A} = \begin{pmatrix} 5 &amp; 5 \\ 5 &amp; 5 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
:: La matrice (5) est de dimension 1 × 1, la valeur « 5 » est donc répétée dans les deux dimensions
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
print(5 + A)
# [[6 7]
#  [7 8]]
&lt;/syntaxhighlight&gt;
: &lt;math&gt;(5, 4) + \mathrm{A} = \begin{pmatrix} 5 &amp; 4 \\ 5 &amp; 4 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(np.array([[5, 4]]) + A)
# [[6 6]
#  [6 8]]
&lt;/syntaxhighlight&gt;
: &lt;math&gt;\begin{pmatrix} 5 \\ 4 \end{pmatrix} + \mathrm{A} = \begin{pmatrix} 5 &amp; 5 \\ 4 &amp; 4 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(np.array([[5], [4]]) + A)
# [[6 7]
#  [7 8]]
&lt;/syntaxhighlight&gt;

== Fonctions « universelles » ==

Les fonctions universelles ''({{lang|en|ufunc}})'' sont les fonctions s'appliquant aux matrices, des fonctions vectorisées.

; Ressource
: {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs
 | titre = Available ufuncs
 | site = SciPy documentation
 | consulté le = 2019-03-21
}}

== Algèbre linéaire ==
{{loupe|../Algèbre linéaire}}

== Notes et références ==
{{références}}

----
[[../Graphiques|Graphiques]] &amp;lt; [[../|↑]] &amp;gt; [[../Polynômes|Polynômes]]

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>hot9mb7nmlybpxy1itpp2c1j6uc0mus</sha1>
    </revision>
    <revision>
      <id>769250</id>
      <parentid>769249</parentid>
      <timestamp>2026-06-30T12:23:19Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Trouver une valeur */ typo</comment>
      <origin>769250</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="26375" sha1="jwasoh9dep1jrfh0k9c0ez1zxyog0vq" xml:space="preserve">Les matrices sont un élément primordial du calcul scientifique sur ordinateur pour deux raisons :
# L'algèbre linéaire est au cœur de nombreux calculs.
# Les matrices sont l'élément de base du calcul vectorisé qui permet un gain de temps appréciable.
Pour pouvoir expliter les matrices, il faut charger le module NumPy ; nous utilisons également Matplotlib pour les graphiques. Ainsi, les programmes contiennent tous au début :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
&lt;/syntaxhighlight&gt;

== Rappels et complément sur le tranchage ==
Soit une liste L composée de ''n'' éléments.
* Les éléments sont numérotés de 0 à ''n'' – 1.
* Le premier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[0]&lt;/code&gt;.
* Le i-ème élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[''i'' - 1]&lt;/code&gt;.
* L'avant-dernier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[-2]&lt;/code&gt;.
* Le dernier élément s'obtient par &lt;code lang=&quot;python&quot;&gt;L[-1]&lt;/code&gt;.
* La sous-liste composée des éléments contigus ''i'' à ''j'' s'obtient par &lt;code lang=&quot;python&quot;&gt;L[''i'' - 1:j]&lt;/code&gt;.
Ainsi, &lt;code lang=&quot;python&quot;&gt;L[0:1]&lt;/code&gt; va extraire le premier élément, &lt;code lang=&quot;python&quot;&gt;L[1:-1]&lt;/code&gt; va extraire tous les éléments sauf le premier et le dernier.

{{voir|[[Python_pour_le_calcul_scientifique/Découverte_de_Python_et_de_Jupyter#Itérable|Découverte_de_Python_et_de_Jupyter &amp;gt; Itérable]]}}

NumPy fournit des fonctions permettant de manipuler les matrices :
* &lt;code lang=&quot;python&quot;&gt;np.append(A, B)&lt;/code&gt; : fusionne les vecteurs A et B ;&lt;br /&gt; s'il s'agit de matrices ou de tenseurs, la fonction les « aplatit », les transforme en vecteur ;&lt;br /&gt;si l'on veut intégrer B dans A, on utilise &lt;code lang=&quot;python&quot;&gt;A = np.append(A, B)&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.append(A, B, axis = ''i'')&lt;/code&gt; : fusionne les tenseurs selon l'indice ''i'' (&lt;code&gt;0&lt;/code&gt; pour le premier indice, &lt;code&gt;1&lt;/code&gt; pour le deuxième…) ;
* &lt;code lang=&quot;python&quot;&gt;np.insert(A, i, m)&lt;/code&gt; : insère le vecteur ''m'' dans le vecteur A (ou la matrice A aplatie) à l'emplacement ''i'' ;
* &lt;code lang=&quot;python&quot;&gt;np.insert(A, i, M, axis = ''j'')&lt;/code&gt; : insère le tenseur M dans le tenseur A à l'emplacement ''i'' de l'indice ''j'' ;
* &lt;code lang=&quot;python&quot;&gt;np.delete(A, I)&lt;/code&gt; : efface les éléments définis par le tranchage I du vecteur A (ou de la matrice A aplatie) ;
* &lt;code lang=&quot;python&quot;&gt;np.delete(A, I, axis = ''j'')&lt;/code&gt; : efface les éléments définis par le tranchage I selon l'indice ''j'' du tenseur A.
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1]])
B = np.array([[2, 3, 4]])
C = np.append(A, B, axis=1)
print(A, B, C, sep=&quot;\n&quot;)
# [[1]]
# [[2 3 4]]
# [[1 2 3 4]]
D = np.array([[10, 20, 30, 40]])
E = np.append(C, D, axis=0)
print(E)
# [[ 1  2  3  4]
#  [10 20 30 40]]
&lt;/syntaxhighlight&gt;
On peut utiliser &lt;code&gt;np.r_[A, B]&lt;/code&gt; pour concaténer A et B en ligne ''(row), et &lt;code&gt;np.c_[A, B]&lt;/code&gt; pour les concaténer en colonne.

On peut extraire une sous-matrice à partir d'une matrice de booléens :
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1, 2], [3, 4], [5, 6]])
booleen = np.logical_or(A==1, A==3)
print(booleen)
# [[ True False]
#  [ True False]
#  [ False False]]
print(A[booleen])
# [1 3]

booleen = np.logical_or(A[:, 0]==1, A[:, 0]==3)
print(booleen)
# [ True  True False]
print(A[booleen])
# [[1 2]
#  [3 4]]
print(A[booleen][:, 1])
# [2 4]
&lt;/syntaxhighlight&gt;

== Différence entre ''array'' et ''matrix'' ==
Il existe deux types d'objet NumPy pour décrire les matrices : les objets ''array'' (tableau, classe &lt;code&gt;ndarray&lt;/code&gt;) et les objets ''matrix'' (matrice, classe &lt;code&gt;matrix&lt;/code&gt;).
&lt;syntaxhighlight lang=&quot;Python&quot;&gt;
A = np.array([[1, 2], [3, 4], [5, 6]])
B = np.matrix([[1, 2], [3, 4], [5, 6]])
&lt;/syntaxhighlight&gt;
Il y a trois différences :
* les objets ''array'' peuvent être de n'importe quelle dimension : 0 (scalaire), 1 (vecteur), 2 (matrice), 3 (tenseur d'ordre 3)… alors qu'un objet ''matrix'' est nécessairement de dimension 2 ;
* les opération sur les objets ''matrix'' sont par défaut des opérations matricielles ; ainsi, la multiplication &lt;code&gt;A * B&lt;/code&gt; va être une multiplication terme à terme si A et B sont des ''array'', et une multiplication matricielle si A et B sont des ''matrix'' ; pour avoir la multiplication matricielle entre ''array'', il faut utiliser &lt;code&gt;a@b&lt;/code&gt; ou &lt;code&gt;np.dot(a,b)&lt;/code&gt; ;
* si une matrice A est inversible, alors avec un objet ''matrix'', on peut utiliser la méthode &lt;code&gt;A.I&lt;/code&gt; ; si A est un objet ''array'', il faut utiliser &lt;code&gt;np.linalg.inv(A)&lt;/code&gt;.

La classe &lt;code&gt;matrix&lt;/code&gt; a été dépréciée, il est recommandé de n'utiliser que la classe &lt;code&gt;ndarray&lt;/code&gt;. Nous n'utiliserons donc pas la classe &lt;code&gt;matrix&lt;/code&gt;.

== Définir un tenseur ==
Un tenseur est similaire à une liste mais il est défini par la fonction &lt;code&gt;np.array()&lt;/code&gt;. La définition et l'extraction de composante utilise la méthode du découpage en tranches ''({{lang|en|slicing}})''.

'''Exemples'''
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 3, 5, 7]) # vecteur
bc = np.array([[1], [2], [3], [4]]) # matrice 4 × 1 (matrice colonne)
bl = np.array([[1, 2, 3, 4]]) # matrice 1 × 4 (matrice ligne)
c = np.array([[1, 2, 3],
              [2, 3, 4],
              [3, 4, 5]]) # matrice 3 × 3
d = np.array([[[1,  2, 3],
               [2,  3, 4]],
              [[10, 9, 8],
               [ 7, 6, 5]]]) # tenseur d'ordre 3, de dimension 3 × 2 × 2
                       
&lt;/syntaxhighlight&gt;
Notez que dans NumPy, un vecteur n'est pas la même chose qu'une matrice ligne ou colonne. Un vecteur de dimension ''n'' est un tenseur d'ordre 1 et de dimension ''n'' ; une matrice ligne ou colonne est un tenseur d'ordre 2 et de dimension 1 × ''n'' ou ''n'' × 1.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 2, 3])
b = np.array([[1, 2, 3]])
c = np.array([[1], [2], [3]])
print(a.size, b.size, c.size) # 3 3 3
print(a.ndim, b.ndim, c.ndim) # 1 2 2
print(a.shape, b.shape, c.shape) # (3,) (1, 3) (3, 1)
&lt;/syntaxhighlight&gt;

La fonction &lt;code&gt;np.arange()&lt;/code&gt; est similaire à la fonction &lt;code&gt;range()&lt;/code&gt; pour les liste ; elle génère un vecteur de réels. La fonction &lt;code&gt;np.linspace()&lt;/code&gt; permet également de créer un vecteur de même type, mais on indique le dernier nombre alors que la règle du découpage en tranches fait que le nombre maximal indiqué à &lt;code&gt;np.arange()&lt;/code&gt; est le premier nombre qui ne ''figure pas'' dans le vecteur.). La fonction &lt;code&gt;np.zeros()&lt;/code&gt; génère une matrice nulle, &lt;code&gt;np.zeros_like()&lt;/code&gt; une matrice nulle ayant les dimensions d'une matrice fournie comme modèle. De même, &lt;code&gt;np.ones()&lt;/code&gt; et &lt;code&gt;np.ones_like()&lt;/code&gt; crée des matrices, dont toutes les composantes sont à 1. La fonction &lt;code&gt;np.eye()&lt;/code&gt; crée une matrice unité.

'''Exemples'''
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
e = np.arange(0, 2, 0.1) # vecteur [0, 0.1, 0.2…, 1.8, 1.9]
f = np.linspace(0, 2, 5) # 5 nombres entre 0 et 2 soit le vecteur [0, 0.5, 1, 1.5, 2]
g = np.zeros(3) # vecteur nul de dimension 3
h = np.zeros((3, 3)) # matrice nulle 3 × 3
k = np.ones_like(a) # matrice de 1 de même dimension que a 
u = np.eye(3) # matrice unité 3 × 3                  
&lt;/syntaxhighlight&gt;
Le paramètre &lt;code&gt;dtype&lt;/code&gt; permet de forcer le type. Par exemple
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([1, 2, 3], dtype=&quot;complex&quot;)
k = np.ones_like(a, dtype=&quot;int&quot;)
&lt;/syntaxhighlight&gt;

La commande &lt;code&gt;np.linspace()&lt;/code&gt; peut créer des matrices colonne : on donne la première et la dernière ligne ; par exemple : :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
np.linspace([1, -1], [10, -10], 4)
# [[  1.  -1.]
#  [  4.  -4.]
#  [  7.  -7.]
#  [ 10. -10.]]
&lt;/syntaxhighlight&gt;
Les commandes &lt;code&gt;np.geomspace()&lt;/code&gt; et &lt;code&gt;np.geomspace()&lt;/code&gt; fonctionnent comme &lt;code&gt;np.linspace()&lt;/code&gt;, mais avec une progression logarithmique. La commande &lt;code&gt;np.geomspace(a, b, n)&lt;/code&gt; crée un vecteur (ou une matrice colonne) allant de ''a'' à ''b'' alors que &lt;code&gt;np.logspace(a, b, n)&lt;/code&gt; crée un vecteur (ou une matrice colonne) allant de 10&lt;sup&gt;''a''&lt;/sup&gt; à 10&lt;sup&gt;''b''&lt;/sup&gt;.

La méthode &lt;code&gt;.reshape()&lt;/code&gt; remet en forme une matrice. Par exemple, pour transformer un vecteur de dimension 9 en une matrice 3 × 3 :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.arange(1, 10)
b = a.reshape(3, 3)
# ou bien directement
c = np.arange(1, 10).reshape(3, 3)         
&lt;/syntaxhighlight&gt;
Avec la méthode &lt;code&gt;.reshape()&lt;/code&gt;, on peut utiliser la valeur –1 pour une des dimensions ; sa valeur est alors automatiquement calculée en fonction du nombre d'éléments et de l'autre dimension. On peut aussi utiliser une dimension vide ; cela crée alors un vecteur. Par exemple, pour une matrice M quelconque :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M.reshape(-1, 1) # crée une matrice colonne
M.reshape(1, -1) # crée une matrice ligne
M.reshape(-1,) # crée un vecteur
&lt;/syntaxhighlight&gt;


La méthode &lt;code&gt;.fill()&lt;/code&gt; remplit la matrice avec un scalaire :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
b.fill(5) # remplace les valeurs de b par la valeur 5
&lt;/syntaxhighlight&gt;

== Extraction matricielle ==
Si l'on veut extraire les colonnes 1 et 3 pour toutes les lignes d'une matrice M, on utilise :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M[:, [0, 2]]
&lt;/syntaxhighlight&gt;

== Trouver une valeur ==
Pour trouver une valeur, on utilise la fonction &lt;code&gt;where()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
print(A)
# [[1 2]
#  [3 4]]
B = np.where(A == 3)
print(B)
# (array([1]), array([0])
print(B[0][0], B[1][0])
# 1 0
C = np.where(A == 5)
print(C)
# (array([], dtype=int64), array([], dtype=int64))
# C est un n-uplet (tuple) contenant deux vecteurs d'entiers vides.
print(len(C[0])) # taille du premier vecteur du n-uplet C
# 0
&lt;/syntaxhighlight&gt;
Notez que &lt;code&gt;where()&lt;/code&gt; peut servir à construire une matrice à partir de deux autres matrices selon une condition. Par exemple, pour comparer les éléments deux à deux et sélectionner le plus grand :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
B = np.array([[0, 1], [4, 5]])
C = np.where(A &gt; B, A, B)
print(C)
# [[1 2]
#  [4 5]
&lt;/syntaxhighlight&gt;
La syntaxyte générale est &lt;code&gt;C = np.where(condition, A, B)&lt;/code&gt; où &lt;code&gt;condition&lt;/code&gt; est une matrice de booléens ; pour un indice (''i'', ''j''), si &lt;code&gt;condition[i, j]&lt;/code&gt; est vrai, alors &lt;code&gt;C[i, j]&lt;/code&gt; vaut &lt;code&gt;A[i, j]&lt;/code&gt;, sinon elle vaut &lt;code&gt;B[i, j]&lt;/code&gt;.

== Assemblage de matrices ==
Si l'on veut regrouper deux matrices, on utilise la commande &lt;code&gt;np.concatenate()&lt;/code&gt;. On utilise le paramètre ''axis'' pour indiquer si l'on empile les matrices l'une au-dessus de l'autre (&lt;code&gt;axis=0&lt;/code&gt;) ou bien l'une derrière l'autre (&lt;code&gt;axis=1&lt;/code&gt;). Par exemple :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1 ,2], [3, 4]])
B = np.array([[5 ,6], [7, 8]])
C = np.concatenate((A, B), axis = 0)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]
D = np.concatenate((A, B), axis = 1)
# [[1 2 5 6]
#  [3 4 7 8]]
&lt;/syntaxhighlight&gt;
Si l'on veut transformer deux vecteurs en une matrice de deux colonnes, chaque vecteur occupant une colonne :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([1 ,2])
B = np.array([3 ,4])
C = np.concatenate((A.reshape(-1, 1), B.reshape(-1, 1)), axis = 1)
# [[1 3]
#  [2 4]]
&lt;/syntaxhighlight&gt;

== Opérations matricielles ==

Les quatre opérations classiques &lt;code lang=&quot;python&gt;+&lt;/code&gt;, &lt;code lang=&quot;python&gt;-&lt;/code&gt; et &lt;code lang=&quot;python&gt;/&lt;/code&gt; ne fonctionnent qu'entre tenseurs de mêmes dimensions et sont des opérations élément par élément ''({{lang|en|elementwise operations}})'' :
* &lt;code lang=&quot;python&quot;&gt;(A + B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] + B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;(A - B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] - B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;(A / B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] / B[i, j, k]&lt;/code&gt;.
La multiplication élément par élément se fait avec
: &lt;code lang=&quot;python&quot;&gt;np.multiply(A, B)&lt;/code&gt; qui vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] * B[i, j, k]&lt;/code&gt;.
De même, les fonctions &lt;code lang=&quot;python&gt;np.add()&lt;/code&gt;, &lt;code lang=&quot;python&gt;np.subtract()&lt;/code&gt;, &lt;code lang=&quot;python&gt;np.multiply()&lt;/code&gt; et &lt;code lang=&quot;python&gt;np.divide()&lt;/code&gt; effectuent des opérations élément par élément sur des tenseurs de mêmes dimensions :
* &lt;code lang=&quot;python&quot;&gt;np.add(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] + B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.subtract(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] - B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.multiply(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] * B[i, j, k]&lt;/code&gt; ;
* &lt;code lang=&quot;python&quot;&gt;np.divide(A, B)[i, j, k]&lt;/code&gt; vaut &lt;code lang=&quot;python&quot;&gt;A[i, j, k] / B[i, j, k]&lt;/code&gt;.
La multiplication matricielle, au sens de l'algèbre linéaire, se fait avec les fonctions &lt;code lang=&quot;python&quot;&gt;np.dot()&lt;/code&gt; ou &lt;code lang=&quot;python&quot;&gt;np.matmul()&lt;/code&gt;, ou bien avec l'opérateur &lt;code&gt;@&lt;/code&gt;.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(a @ b) # np.matmul(a, b)
# [[19 22]
# [43 50]]
&lt;/syntaxhighlight&gt;
Pour un poduit scalaire :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([1, 2, 3])
B = np.array([4, 5, 6])
# 32
&lt;/syntaxhighlight&gt;

Notez que :
* pour le produit par un scalaire, les fonctions &lt;code lang=&quot;python&quot;&gt;np.multiply()&lt;/code&gt; et l'opérateur &lt;code lang=&quot;python&quot;&gt;*&lt;/code&gt; sont plus performants ;
* la fonction &lt;code lang=&quot;python&quot;&gt;np.dot()&lt;/code&gt; est plus performante pour le produit scalaire de deux vecteurs réels ;
* lorsque l'on a des vecteurs complexes, la fonction &lt;code lang=&quot;python&quot;&gt;np.vdot()&lt;/code&gt; fait le produit par le conjugué du premier membre (&lt;code lang=&quot;python&quot;&gt;np.vdot(a, b) == np.dot(a.conj(), b)&lt;/code&gt;) ;
* la fonction &lt;code lang=&quot;python&quot;&gt;np.matmul()&lt;/code&gt; et l'opérateur &lt;code lang=&quot;python&quot;&gt;@&lt;/code&gt; (&lt;code lang=&quot;python&quot;&gt;A @ B&lt;/code&gt;) sont plus performants pour un produit matriciel.
L'opérateur &lt;code&gt;@=&lt;/code&gt; fait un produit matriciel en modifiant la variable elle-même (à l'image de &lt;code&gt;*=&lt;/code&gt; pour les nombres).

== Calcul vectorisé ==

Les fonctions de NumPy traitent en général les matrices en entier. Ainsi, il n'est pas nécessaire de créer une boucle pour faire défiler les indices un par un. Il en résulte un code clair et compact et surtout un plus grande rapidité d'exécution. Par exemple :

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
x = np.linspace(0, 2*np.pi, 50) # 50 points entre 0 et 2π
y = np.sin(x)
plt.plot(x, y)
&lt;/syntaxhighlight&gt;
La variable &lt;code&gt;x&lt;/code&gt; est un vecteur de 50 valeurs et il est traité en une seule passe par la fonction sinus &lt;code&gt;np.sin()&lt;/code&gt;.

Outre le tranchage ''({{lang|en|slicing}})'', on peut utiliser deux autres méthodes pour extraire certaines valeurs d'une matrice :
* utiliser un vecteur ou une matrice d'indices, Python extrait alors les valeurs correspondant aux indices ;
* utiliser un vecteur ou une matrice de booléens de même dimension que a matrice ; Python extrait alors les valeurs correspondant aux &lt;code&gt;True&lt;/code&gt;, la matrice booléenne est un « masque » pour la matrice d'origine. Par exemple : 

&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.arange(0, 10)
b = np.array([1, 3, 5, 7, 9])
c = np.array([True, True, False, False, True, False, True, False, False, True])
print(a[b], &quot;\n&quot;, a[c])
&lt;/syntaxhighlight&gt;

Si l'on veut inverser tous les éléments d'une matrice de bolléens, il faut utiliser la fonction &lt;code&gt;np.logical_not()&lt;/code&gt;

'''Exercice'''
 
Écrire un programme Python mettant en œuvre le [[w:crible d'Érathostène|crible d'Érathostène]] pour trouver les nombres premiers inférieurs à une valeur donnée.

{{boîte déroulante début|Solution}}
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
#!/usr/bin/env python
# coding: utf-8

import numpy as np
import matplotlib.pyplot as plt

# ***************
# ***************
# ** Fonctions **
# ***************
# ***************

def eratosthene(limite):
    # Détermine la liste des nombres premiers entre 1 et N
    #     par le crible d'Ératosthène
    # Entrées : limite : nombre entier, N
    # Sorties : liste : vecteur d'entiers,liste des nombres premiers
    
    indices = (np.ones(limite) == 1) # vecteur de booléens tous à True
    # à la fin, indice(i-1) est True si i est premier, False sinon
    indices[0]=False # 1 n'est pas premier
    imax = int(limite)
    i = 2 # initialisation
    repete = (i &lt;= imax)
    while repete:
        if indices[i-1]:
            jmax = int(limite/i)
            j = np.arange(1, jmax)+1
            indices[i*j-1]=False # élimination des multiples de i
            test = (i*jmax == imax)
        i = i + 1
        repete = i*i &lt; limite # condition d'arrêt
    liste0 = np.arange(limite)
    liste = liste0[indices]+1
    return liste

# *************************
# *************************
# ** Programme principal **
# *************************
# *************************

print(&quot;***** Recherche de nombres premiers par le crible d'Ératosthène *****\n&quot;)

nmax = eval(input(&quot;Entrez la valeur maximale : &quot;))
resultat = eratosthene(nmax)

print(&quot;\n&quot;, resultat.shape[0], &quot;nombres premiers entre 1 et&quot;, nmax, &quot;:\n&quot;)
print(resultat)

plt.plot(resultat, np.zeros_like(resultat), &quot;|&quot;)
&lt;/syntaxhighlight&gt;

L'extraction par un vecteur d'indice intervient dans l'instruction :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
indices[i*j-1]=False
&lt;/syntaxhighlight&gt;
qui élimine en une seule passe tous les multiples de ''i''. L'extraction par un vecteur booléen intervient dans l'instruction :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
liste = liste0[indices]+1
&lt;/syntaxhighlight&gt;
qui permet d'extraire toutes la valeurs conservées en une seule passe.
{{boîte déroulante fin}}

== Attributs ==

La classe &lt;code&gt;ndarray&lt;/code&gt;, qui définit les matrices, possède un certain nombre d'attributs :
* &lt;code&gt;.shape&lt;/code&gt; : dimensions de la matrice ;
* &lt;code&gt;.ndim&lt;/code&gt; : ordre du tenseur ; 
* &lt;code&gt;.size&lt;/code&gt; : nombre d'éléments ;
* &lt;code&gt;.dtype&lt;/code&gt; : type des éléments.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.linspace(1, 9, 9)
print(&quot;a&quot;, a, &quot;\n&quot;,
    &quot; ; shape :&quot;, a.shape,
    &quot; ; dim : &quot;, a.ndim,
    &quot; ; size : &quot;, a.size,
    &quot; ; dtype : &quot;, a.dtype, &quot;\n&quot;)
&lt;/syntaxhighlight&gt;
* &lt;code&gt;.real&lt;/code&gt;, &lt;code&gt;.imag&lt;/code&gt; : parties réelle et imaginaire de la matrice ;
* &lt;code&gt;.flat&lt;/code&gt; : liste des éléments de la matrice ; les éléments sont réorganisés en une liste ;
* &lt;code&gt;.T&lt;/code&gt; : transposée.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;a = np.arange(0, 9).reshape(3, 3)
print(a)
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]] 
print(a.T)
# [[0 3 6]
#  [1 4 7]
#  [2 5 8]] 
print(a.flat[:])
# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
&lt;/syntaxhighlight&gt;
; Ressources
: Section « Attribute », {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
 | titre = numpy.ndarray
 | site = Numpy and Scipy Documentation
 | consulté le = 2019-03-16
}}

== Fonctions et méthodes de base ==

La classe &lt;code&gt;ndarray&lt;/code&gt; possède un certain nombre de méthodes :
* &lt;code&gt;.min()&lt;/code&gt; et &lt;code&gt;.max()&lt;/code&gt; : valeurs respectivement minimale et maximale ;
* &lt;code&gt;.ptp()&lt;/code&gt; : amplitude « max – min » ''({{lang|en|peak to peak}})'' ;
* &lt;code&gt;.argmin()&lt;/code&gt; et &lt;code&gt;argmax()&lt;/code&gt; : indice où se trouvent les valeurs respectivement minimale et maximale ;
* &lt;code&gt;.sum()&lt;/code&gt;, &lt;code&gt;prod()&lt;/code&gt; : somme et produit de tous les éléments de la matrice ;
* &lt;code&gt;.cumsum()&lt;/code&gt;, &lt;code&gt;cumprod()&lt;/code&gt; : somme et produit cumulés.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = np.linspace(1, 9, 9)
print(&quot;min : &quot;, a.min(),
    &quot;; max : &quot;, a.max(), &quot;\n&quot;,
    &quot;sum : &quot;, a.sum(),
    &quot;; cumsum : &quot;, a.cumsum(), &quot;\n&quot;,
    &quot;prod : &quot;, a.prod(),
    &quot;; cumprod : &quot;, a.cumprod(), &quot;\n&quot;)
&lt;/syntaxhighlight&gt;

Méthodes statistiques :
* &lt;code&gt;.mean()&lt;/code&gt; : moyenne ;
* &lt;code&gt;.std()&lt;/code&gt; : écart type ''({{lang|en|standard deviation}})''.
{{loupe|../Statistiques}}

Extraction de données :
* &lt;code&gt;.diagonal()&lt;/code&gt; : vecteur contenant les éléments de la diagonale ;
* &lt;code&gt;.flatten()&lt;/code&gt; : matrice « aplatie », c'est-à-dire vecteur contenant les éléments réorganisés en liste ; par rapport à l'attribut &lt;code&gt;.flat&lt;/code&gt;, on peut choisir le sens de linéarisation (par lignes, &lt;code&gt;.flatten(C)&lt;/code&gt;, ou par colonnes, &lt;code&gt;.flatten(F)&lt;/code&gt;) mais cela crée une copie, on ne peut pas par exemple s'en servir pour modifier la matrice ;
* &lt;code&gt;.tofile()&lt;/code&gt; : crée un fichier texte contenant les valeurs de la matrice ; par exemple, pour une matrice &lt;code&gt;a&lt;/code&gt; et pour séparer les valeurs par un point-virgule :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a.tofile(&quot;matriceA.txt&quot;, sep=&quot; ; &quot;)
&lt;/syntaxhighlight&gt;
* &lt;code&gt;.astype(''type'')&lt;/code&gt; : copie la matrice en convertissant le type de données :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
a = a.astype(float) # pour avoir une matrice de réels en virgule flottante
a = a.astype(str) # pour avoir une matrice de chaînes de caractères
&lt;/syntaxhighlight&gt;

Tri :
* &lt;code&gt;np.sort(M, i)&lt;/code&gt; : crée une copie et trie la matrice selon l'axe ''i'' (0 pour le premier indice, 1 pour le deuxième… la valeur par défaut est –1 pour le dernier indice, la valeur ''none'' aplatit la matrice) ; &lt;code&gt;np.sort(M, 0)&lt;/code&gt; trie chaque colonne indépendamment par ordre croissant, &lt;code&gt;np.sort(M, 1)&lt;/code&gt; trie chaque ligne indépendamment par ordre croissant ;
* &lt;code&gt;M.sort(i)&lt;/code&gt; : cette méthode trie la matrice en elle-même ;
* &lt;code&gt;np.argsort(M, i)&lt;/code&gt; : crée une matrice contenant le nouvel indice, selon l'axe ''i'', de chaque élément.
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5]])
M.sort(1) # tri des lignes indépendamment -&gt; [[1, 5, 5, 7], [2, 3, 4, 9], [1, 5, 7, 9]]
&lt;/syntaxhighlight&gt;
Pour trier les lignes selon la deuxième colonne d'une matrice, tout en conservant les lignes intactes, on peut faire comme suit :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5]])
ind = np.argsort(M[:, 1]) # indices de tri selon la 2e colonne
N = M[ind, :] # réarrangement des lignes -&gt; [[9, *1*, 7, 5], [1, *5*, 7, 5], [2, *9*, 4, 3]]
&lt;/syntaxhighlight&gt;
Pour faire un tri lexicographique, on utilise la fonction &lt;code&gt;np.lexsort()&lt;/code&gt; en indiquant les différentes colonnes :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = np.array([[1, 5, 7, 5], [2, 9, 4, 3], [9, 1, 7, 5], [2, 9, 8, 5]])
ind = np.lexsort((M[:, 3], M[:, 2], M[:, 1], M[:, 0])) # indices de tri selon la 1re, puis la 2e, puis la 3e, puis la 4e colonne
N = M[ind, :] # réarrangement des lignes -&gt; [[1, 5, 7, 5], [2, 9, 4, 3], [2, 9, 8, 5], [9, 1, 7, 5]]
&lt;/syntaxhighlight&gt;
Le tri se fait par ordre croissant. Pour trier par ordre décroissant, on inverse l'ordre de la matrice en faisant une extraction avec un pas de moins un, par exemple pour inverser les lignes :
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
M = M[:, ::-1]
&lt;/syntaxhighlight&gt;

Algèbre linéaire :
* &lt;code&gt;a.dot(b)&lt;/code&gt; : produit matriciel ''a''⋅''b'' ; on peut aussi écrire &lt;code&gt;a@b&lt;/code&gt; ;
* &lt;code&gt;.trace()&lt;/code&gt; : trace de la matrice (somme des éléments diagonaux) ;
* &lt;code&gt;.transpose()&lt;/code&gt; : transpose la matrice, résultat similaire à l'attribut &lt;code&gt;.T&lt;/code&gt; ;
* &lt;code&gt;np.cross()&lt;/code&gt; : produit vectoriel dans ℝ³.
{{loupe|../Algèbre linéaire}}

Matrices de booléens :
* &lt;code&gt;.all()&lt;/code&gt; : applique un « et » logique à toutes les valeurs de la matrice ;
* &lt;code&gt;.any()&lt;/code&gt; : applique un « ou » logique à toutes les valeurs de la matrice.
{{loupe|../Fonctions mathématiques générales#Fonctions booléennes}}

Autre méthodes :
* &lt;code&gt;.conj()&lt;/code&gt; : conjugué des valeurs complexes ;
* &lt;code&gt;.nonzero()&lt;/code&gt; : n-uplet contenant les indices des valeurs non-nulles ;
* &lt;code&gt;.round(n)&lt;/code&gt; : arrondit les valeurs à la ''n''-ième décimale.

; Ressources
: Section « Method », {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html
 | titre = numpy.ndarray
 | site = Numpy and Scipy Documentation
 | consulté le = 2019-03-16
}}

== Propagation ==

Le terme « propagation » ''({{lang|en|broadcasting}})'' désigne la manière dont Python complète les matrice lorsque des dimensions manquent. 

Supposons que l'on veuille additionner deux matrices M&lt;sub&gt;1&lt;/sub&gt; et M&lt;sub&gt;2&lt;/sub&gt; de dimensions ''m''&lt;sub&gt;1&lt;/sub&gt; × ''n''&lt;sub&gt;1&lt;/sub&gt; et ''m''&lt;sub&gt;2&lt;/sub&gt; × ''n''&lt;sub&gt;2&lt;/sub&gt; différentes. Alors :
* le résultat a pour dimension max(''m''&lt;sub&gt;1&lt;/sub&gt;, ''m''&lt;sub&gt;2&lt;/sub&gt;) × max(''n''&lt;sub&gt;1&lt;/sub&gt;, ''n''&lt;sub&gt;2&lt;/sub&gt;) ;
* si une des dimensions vaut 1, alors les valeurs de l'autre dimension sont dupliquées ;
* sinon, les dimensions manquantes pour chaque matrice sont complétées par des 1.
Par exemple :
: &lt;math&gt;\mathrm{A} = \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
: &lt;math&gt;5 + \mathrm{A} = \begin{pmatrix} 5 &amp; 5 \\ 5 &amp; 5 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
:: La matrice (5) est de dimension 1 × 1, la valeur « 5 » est donc répétée dans les deux dimensions
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
A = np.array([[1, 2], [3, 4]])
print(5 + A)
# [[6 7]
#  [7 8]]
&lt;/syntaxhighlight&gt;
: &lt;math&gt;(5, 4) + \mathrm{A} = \begin{pmatrix} 5 &amp; 4 \\ 5 &amp; 4 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(np.array([[5, 4]]) + A)
# [[6 6]
#  [6 8]]
&lt;/syntaxhighlight&gt;
: &lt;math&gt;\begin{pmatrix} 5 \\ 4 \end{pmatrix} + \mathrm{A} = \begin{pmatrix} 5 &amp; 5 \\ 4 &amp; 4 \end{pmatrix} + \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 4 \end{pmatrix} &lt;/math&gt;
&lt;syntaxhighlight lang=&quot;python&quot;&gt;
print(np.array([[5], [4]]) + A)
# [[6 7]
#  [7 8]]
&lt;/syntaxhighlight&gt;

== Fonctions « universelles » ==

Les fonctions universelles ''({{lang|en|ufunc}})'' sont les fonctions s'appliquant aux matrices, des fonctions vectorisées.

; Ressource
: {{lien web
 | url = https://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs
 | titre = Available ufuncs
 | site = SciPy documentation
 | consulté le = 2019-03-21
}}

== Algèbre linéaire ==
{{loupe|../Algèbre linéaire}}

== Notes et références ==
{{références}}

----
[[../Graphiques|Graphiques]] &amp;lt; [[../|↑]] &amp;gt; [[../Polynômes|Polynômes]]

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>jwasoh9dep1jrfh0k9c0ez1zxyog0vq</sha1>
    </revision>
  </page>
  <page>
    <title>Découvrir Scilab/Régression</title>
    <ns>0</ns>
    <id>73083</id>
    <revision>
      <id>769251</id>
      <parentid>700978</parentid>
      <timestamp>2026-06-30T21:09:17Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Régression polynomiale */ moins demi-cadratin</comment>
      <origin>769251</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="15354" sha1="0z5vzyi485vxsuiiwatioeli2txoeg8" xml:space="preserve">&lt;noinclude&gt;{{NavTitre|book={{BASEPAGENAME}}|prev=Interpolation, extrapolation et lissage|next=Calcul différentiel et intégral}}&lt;/noinclude&gt;
{{Scilab}}

&lt;br /&gt;
&lt;span style=&quot;font-size:25px;&quot;&gt;6. Régression&lt;/span&gt;
----

'''Présentation du problème'''

Le problème a des similarités avec celui de l'interpolation : on a des points expérimentaux (''x&lt;sub&gt;i&lt;/sub&gt;'', ''y&lt;sub&gt;i&lt;/sub&gt;''), et l'on détermine une fonction décrivant ces points. Les différences majeures sont :
* la fonction est déterminée sur l'ensemble de définition complet, à partir de tous les points, et non pas par morceaux entre deux points ;
* la fonctions ne passe en général pas ''par'' les points expérimentaux mais ''près'' de ces points.
Par ailleurs, la forme de la fonction est souvent déterminée par le type de problème auquel on s'attaque, elle a un « sens physique », là où l'interpolation se contente de prendre des fonctions simples.

Considérons un nuage de ''n'' points « expérimentaux » (X, Y) : X et Y sont des vecteurs
* X = [X&lt;sub&gt;1&lt;/sub&gt; ; X&lt;sub&gt;2&lt;/sub&gt; ; … ; X&lt;sub&gt;''n''&lt;/sub&gt;] ;
* Y = [Y&lt;sub&gt;1&lt;/sub&gt; ; Y&lt;sub&gt;2&lt;/sub&gt; ; … ; Y&lt;sub&gt;''n''&lt;/sub&gt;].
Considérons une fonction « modèle » ''y'' = ƒ(A, ''x'') où A est un vecteur ; les valeurs de A sont des paramètres de la fonction ƒ, par exemple :
* ƒ(A, ''x'') = A(1)·exp((''x'' - A(2))&lt;sup&gt;2&lt;/sup&gt;/A(3)) : une fonction gaussienne ;
* ƒ(A, ''x'') = A(1)·''x''&lt;sup&gt;3&lt;/sup&gt; + A(2)·''x''&lt;sup&gt;2&lt;/sup&gt; + A(3)·''x'' + A(4) : un polynôme de degré 3.
La régression consiste à trouver le vecteur A tel que la fonction ƒ « colle le mieux » au nuage de points. On utilise pour cela la méthode des moindres carrés ''(least square)'' :
* on définit la fonction « résidus » ''r''(A, ''x'', ''y'') entre le modèle et les points expérimentaux : 
*: ''r''(A, ''x'', ''y'') = ''y'' - ƒ(A, ''x'') ;
* on définit la somme S des carrés des résidus comme étant :
*: S = ∑&lt;sub&gt;''i''&lt;/sub&gt; ''r''&lt;sup&gt;2&lt;/sup&gt;(A, X&lt;sub&gt;''i''&lt;/sub&gt;, Y&lt;sub&gt;''i''&lt;/sub&gt;) ;
la régression par la méthode des moindres carrés consiste donc à trouver le vecteur A donnant la valeur minimale de S.

== Régression linéaire ==

=== Régression linéaire simple ===

Dans le cas de la régression linéaire, la fonction modèle ƒ est une fonction affine :
: ƒ(A, ''x'') = A(1)·''x'' + A(2).
Comme il n'y a que deux paramètres dans le modèle, on note ceux-ci ''a'' et ''b'' :
: ƒ(''a'', ''b'', ''x'') = ''a''·''x'' + ''b''.

D'une certaine manière, la régression consiste à résoudre un système d'équations surdéterminé (chaque point expérimental étant une équation, il y a plus d'équations que d'inconnues) :
: &lt;math&gt;\begin{cases}
 a x_1 + b = y_1 \\
 a x_2 + b = y_2 \\
\ldots \\
 a x_n + b = y_n \\
\end{cases}&lt;/math&gt;
ce qui peut s'écrire sous forme matricielle
: A×X = Y
avec
: A = (''a'' ''b'')
: &lt;math&gt;\mathrm{X} = \begin{pmatrix}
x_1 &amp; x_2 &amp; \ldots &amp; x_n \\
 1  &amp;  1  &amp; \ldots &amp; 1 \\
\end{pmatrix}&lt;/math&gt;
: Y = (''y''&lt;sub&gt;1&lt;/sub&gt; ''y''&lt;sub&gt;2&lt;/sub&gt; … ''y&lt;sub&gt;n&amp;thinsp;&lt;/sub&gt;'')
Si l'on demande à Scilab de résoudre le système avec la division matricielle alors que la matrice X n'est pas carrée, il effectue automatiquement une régression linéaire des moindres carrés : 
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
\\ génération des données de test
x = 1:10
y = x + 0.3*rand(x);

\\ régression
X = [x ; ones(x)];
A = y/X
&lt;/syntaxhighlight&gt;

Si l'on veut forcer l'ordonnée à l'origine à 0, il suffit de ne pas mettre la ligne de 1 :
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
A = y/x
&lt;/syntaxhighlight&gt;

On peut aussi travailler avec des vecteurs colonne, et utiliser l'autre diviseur matriciel &lt;code&gt;A = x\y&lt;/code&gt;.

Mais la méthode de la division matricielle ne donne pas d'autre information que les coefficients, et en particulier ne donne pas le résidu.

Pour cela, on peut utiliser la fonction &lt;code&gt;reglin()&lt;/code&gt;, avec la syntaxe :

&lt;syntaxhighlight lang = &quot;scilab&quot;&gt;
// définition du nuage de points
X = […];
Y = […];

// régression
[a, b, sigma] = reglin(X, Y);
&lt;/syntaxhighlight&gt;

{{note
 | Les matrices X et Y doivent être des vecteurs ''ligne''.
}}

On peut aussi utiliser la commande &lt;code&gt;regress()&lt;/code&gt;. Elle ne permet pas d'obtenir l'écart type, et ne fonctionne qu'avec deux variables, mais par contre, les vecteurs peuvent être indifféremment ligne ou colonne ; ils peuvent même être de types différents (un vecteur ligne et l'autre colonne).

&lt;syntaxhighlight lang = &quot;scilab&quot;&gt;
coefs = regress(X, Y)
&lt;/syntaxhighlight&gt;

'''Exemple'''

Dans l'exemple suivant, on génère des points dispersés aléatoirement autour d'une droite &lt;code&gt;y = pente*x + ordonnee&lt;/code&gt;, puis on fait la régression linéaire de ce nuage de points.

Pour clarifier le code source, le programme est scindé en trois fichiers situés dans le même répertoire (dossier) appelé ici &lt;code&gt;monrepertoire/&lt;/code&gt; :
* le fichier &lt;code&gt;fonction.sce&lt;/code&gt; qui contient la fonction affine ;
* le fichier &lt;code&gt;generation.sce&lt;/code&gt; qui crée un nuage de points et le met dans le fichier &lt;code&gt;donnees.txt&lt;/code&gt; ;
* le fichier &lt;code&gt;regression.sce&lt;/code&gt; qui lit le fichier &lt;code&gt;donnees.txt&lt;/code&gt; et effectue la régression.

: Fichier &lt;code&gt;fonction.sce&lt;/code&gt;
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
chdir(&quot;monrepertoire/&quot;);

// **********
// Constantes
// **********

// **********
// Fonctions
// **********

deff(&quot;[y] = affine(a, b, x)&quot;, &quot;y = a*x + b&quot;)
&lt;/syntaxhighlight&gt;

: Fichier &lt;code&gt;generation.sce&lt;/code&gt;
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
chdir(&quot;monrepertoire/&quot;);

// **********
// Constantes
// **********

// paramètres de la loi affine
pente = 1;
ordonnee = 10;

// paramètres de la loi normale
var = 1; // variance

// nombre de points
nbpts = 20;

// **********
// Initialisation
// **********

X = zeros(nbpts)';
Y = zeros(nbpts)';

// **********
// Fonctions
// **********

exec(&quot;fonction.sce&quot;, -1) // charge le fichier (-1 : sans commentaire)

// **********
// Programme principal
// **********

// nuage de points
for i = 1:nbpts
    X(1,i) = i + var*rand(1, &quot;normal&quot;);
    Y(1,i) = affine(pente, ordonnee, i) + var*rand(1, &quot;normal&quot;);
end

// enregistrement

write(&quot;donnees.txt&quot;, [X,Y]);
&lt;/syntaxhighlight&gt;

: Fichier &lt;code&gt;regression.sce&lt;/code&gt;
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
clf;
chdir(&quot;monrepertoire/&quot;);

// **********
// Programme principal
// **********

// lecture des données
donnees = read(&quot;donnees.txt&quot;, -1, 2)
Xexp = donnees(:,1);
Yexp = donnees(:,2);


// regression
[aopt, bopt, sigma] = reglin(Xexp, Yexp)

// loi modèle
Yopt = affine(aopt, bopt, X);

// affichage
plot(Xexp, Yexp, &quot;+b&quot;)
plot(Xexp, Yopt, &quot;-r&quot;)
xstring(0, ordonnee, &quot;a = &quot;+string(aopt)+&quot; pour &quot;+string(pente)...
+&quot; ; b = &quot;+string(bopt)+&quot; pour &quot;+string(ordonnee)...
+&quot; ; sigma = &quot;+string(sigma))
&lt;/syntaxhighlight&gt;

Comme la forme de la fonction ƒ est connue, il est inutile de la définir. La fonction &lt;code&gt;reglin()&lt;/code&gt; retourne un vecteur de trois composantes : les paramètres ''a'' et ''b'' du modèle, et l'écart type σ du résidu (qui est la racine carrée de la somme des carrés des résidus, σ = √S).

=== Régression multilinéaire ===

Notons que ''a'', ''b'', ''x'' et ''y'' peuvent être des vecteurs. Si par exemple on a un modèle linéaire à plusieurs variables :
: ƒ(''a''&lt;sub&gt;1&lt;/sub&gt;, ''a''&lt;sub&gt;2&lt;/sub&gt;, …, ''a''&lt;sub&gt;''m''&lt;/sub&gt;, ''b'', ''x''&lt;sub&gt;1&lt;/sub&gt;, ''x''&lt;sub&gt;2&lt;/sub&gt;, …''x''&lt;sub&gt;''n''&lt;/sub&gt;) = ''a''&lt;sub&gt;1&lt;/sub&gt;·''x''&lt;sub&gt;1&lt;/sub&gt; + ''a''&lt;sub&gt;2&lt;/sub&gt;·''x''&lt;sub&gt;2&lt;/sub&gt; + … + ''a''&lt;sub&gt;''n''&lt;/sub&gt;·''x''&lt;sub&gt;''n''&lt;/sub&gt;  + ''b''
alors il suffit de définir X comme étant une matrice ''m''×''n''
 X = [X&lt;sub&gt;11&lt;/sub&gt;, X&lt;sub&gt;12&lt;/sub&gt;, … X&lt;sub&gt;1''n''&lt;/sub&gt; ;
      X&lt;sub&gt;21&lt;/sub&gt;, X&lt;sub&gt;22&lt;/sub&gt;, … X&lt;sub&gt;2''n''&lt;/sub&gt; ;
      …
      X&lt;sub&gt;''m''1&lt;/sub&gt;, X&lt;sub&gt;''m''2&lt;/sub&gt;, … X&lt;sub&gt;''mn''&lt;/sub&gt;]
où X&lt;sub&gt;''ij''&lt;/sub&gt; est la valeur de ''x&lt;sub&gt;j&lt;/sub&gt;'' pour le point de mesure ''i'' ; et de définir Y comme étant un vecteur ligne de ''n'' valeurs
 Y = [Y&lt;sub&gt;1&lt;/sub&gt;, Y&lt;sub&gt;2&lt;/sub&gt;, … , Y&lt;sub&gt;''n''&lt;/sub&gt;]
et le paramètre ''a'' retourné par la division matricielle ou par la fonction &lt;code&gt;reglin()&lt;/code&gt; est le vecteur [''a''&lt;sub&gt;1&lt;/sub&gt;, ''a''&lt;sub&gt;2&lt;/sub&gt;, … , ''a''&lt;sub&gt;''n''&lt;/sub&gt;].

== Régression polynomiale ==

La régression polynomiale est un cas particulier de régression multilinéaire.

{{loupe|wikipedia:fr:Régression polynomiale}}

Voici par exemple un programme générant ''n'' points pour ''x'' allant de 0 à 5 (valeurs exactes), et ''y'' suivant le polynôme ''x''&lt;sup&gt;3&lt;/sup&gt; – 2·''x''&lt;sup&gt;2&lt;/sup&gt; + 3·''x'' – 4, bruité :

&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
// n points aléatoires approchant un polynôme de degré 3

// chdir(&quot;mon_chemin_d_acces&quot;); // répertoire où enregistrer le fichier

n = 10;
x = linspace(0, 5, n);
P = %s^3 - 2*%s^2 - 3*%s + 4;

y = horner(P, x); // valeurs exactes du polynôme

clf;
plot(x, y); // tracé du polynôme

y = y + 3*rand(y, &quot;normal&quot;); // valeurs bruitées

plot(x, y, &quot;+&quot;); // tracé des points bruités

write(&quot;polynome_bruite.txt&quot;, [x' , y']);
&lt;/syntaxhighlight&gt;

Et voici un programme permettant d'effectuer la régression sur ces données :

&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
// Régression polynomiale de degré 3

// chdir(&quot;mon_chemin_d_acces&quot;); // répertoire où chercher le fichier


M = read(&quot;polynome_bruite.txt&quot;, -1, 2); // lecture des données

x = M(:, 1);
y = M(:, 2);

X = [x.^3, x.^2, x, ones(x)];

A = X\y; // régression linéaire par les moindres carrés

P = [%s^3, %s^2, %s, 1]*A; // définition du polynôme

yth = horner(P, x); // valeurs correspondant au polynôme

// tracé du résultat
clf;
plot(x, yth)
plot(x, y, &quot;+&quot;)
&lt;/syntaxhighlight&gt;

== Régression non-linéaire ==

Dans le cas de la régression non-linéaire, ƒ est une fonction quelconque. Pour effectuer la régression, on utilise la fonction &lt;code&gt;leastsq()&lt;/code&gt; avec la syntaxe suivante :
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
// fonction modèle
function y = f(A, x)
   ...
endfunction 

// fonction résidus
function e = r(A, x, y)
   e = f(A, x) - y
endfunction

// initialisation des paramètres du modèle
Ainit = […];

// définition du nuage de points
X = […];
Y = […];

[S, Aopt] = leastsq(list(r, X, Y), Ainit)
&lt;/syntaxhighlight&gt;
Avec cette syntaxe, la fonction &lt;code&gt;leastsq()&lt;/code&gt; retourne donc un vecteur :
* le premier élément, &lt;code&gt;S&lt;/code&gt;, est la valeur de la somme des carrés des écarts ;
* le second élément, &lt;code&gt;Aopt&lt;/code&gt;, est le vecteur contenant la valeur « optimisée » des paramètres du modèle.

{{note
 | Les matrices X et Y doivent être ici des vecteurs ''colonne''. Par ailleurs, la fonction de calcul du résidu doit s'appliquer aux ''vecteurs'' X et Y, pour renvoyer un ''vecteur'' e.
}}

''' Exemple 1'''

Nous reprenons l'exemple de la régression linéaire, mais en utilisant cette fois-ci la fonction &lt;code&gt;leastsq()&lt;/code&gt;. Lorsque l'on enregistre les données générées, on utilise :
&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
write(&quot;donnees.txt&quot;, [X', Y']);
&lt;/syntaxhighlight&gt;
afin d'avoir des vecteurs colonne.

&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
clf;
chdir(&quot;monrepertoire/&quot;);

// **********
// Initialisation
// **********

Ainit=[1;1];

// **********
// Fonctions
// **********

deff(&quot;[y] = f(a, b, x)&quot;, &quot;y = a*x + b&quot;)

deff(&quot;[e] = res(A, x, y)&quot;, &quot;e = f(A(1),A(2),x) - y&quot;)

// **********
// Programme principal
// **********
 
// lecture des données
donnees = read(&quot;donnees.txt&quot;, -1, 2)
Xexp = donnees(:, 1);
Yexp = donnees(:, 2);
 
// regression
[S, Aopt] = leastsq(list(res, Xexp, Yexp),Ainit)
 
// loi modèle
Ymod = f(Aopt(1), Aopt(2), Xexp);
 
// affichage
plot(Xexp, Ymod, &quot;-r&quot;)
plot(Xexp, Yexp, &quot;+b&quot;)
xstring(0, ordonnee, &quot;a = &quot;+string(Aopt(1))+&quot; pour &quot;+string(pente)...
+&quot; ; b = &quot;+string(Aopt(2))+&quot; pour &quot;+string(ordonnee)...
+&quot; ; variance = &quot;+string(S))
&lt;/syntaxhighlight&gt;

[[File:Desommation gaussienne lorentzienne.svg|vignette|upright=2|Résultat de la régression.]]

''' Exemple 2'''

Nous travaillons ici avec un pic généré par la somme d'une fonction gaussienne et d'une fonction lorentzienne. Ce genre de profil est classiquement utilisé pour décrire la forme des pics obtenus par diffractométrie X. On fait ce que l'on appelle une désommation de pics (on parle souvent de « déconvolution », mais ce terme est abusif puisqu'il ne s'agit pas de produit de convolution).

&lt;syntaxhighlight lang=&quot;scilab&quot;&gt;
clf()

// **********
// Constantes
// **********

paramlorentz(1) = 5; // hauteur de la courbe lorentzienne
paramlorentz(2) = 2; // largeur de la courbe lorentzienne
paramgauss(1) = 10; // hauteur de la courbe gaussienne
paramgauss(2) = 3; // largeur de la courbe gaussienne
var=0.5; // variance de la loi normale
nbpts = 100 // nombre de points
demielargeur = max(3*paramgauss(2), 3*paramlorentz(2)) // pour intervalle x
pas = 2*demielargeur/nbpts;
Ainit = [1;1;1;1]; // paramètres initiaux du modèle

// **********
// Initialisation
// **********

X = zeros(nbpts,1);
Y = zeros(nbpts,1);
Yopt = zeros(nbpts,1);

// **********
// Fonctions
// **********

// Fonction gaussienne centrée sur 0

function [y] = gauss(A, x)
    // A(1) : hauteur de pic
    // A(2) : &quot;largeur&quot; du pic
    y = A(1)*exp(-x.*x/A(2));
endfunction

// Fonction lorentzienne centrée sur 0

function [y] = lorentz(A, x)
    // A(1) : hauteur de pic
    // A(2) : &quot;largeur&quot; du pic
    foo = A(2)*A(2)
    y = foo*A(1)./(foo + 4*x.*x);
endfunction

function [y] = profil(A, x)
    // A(1) : hauteur de pic lorentzien
    // A(2) : &quot;largeur&quot; du pic lorentzien
    // A(3) : hauteur de pic gaussien
    // A(4) : &quot;largeur&quot; du pic gaussien
    L = A(1:2);
    G = A(3:4);
    y = lorentz(L, x) + gauss(G, x);
endfunction

// Résidus

function [e] = residus(A, x, y)
    e = profil(A, x) - y;

endfunction

// **********
// Nuage de points
// **********

i=(1:nbpts)';
X = pas*i - demielargeur;
Y = profil([paramlorentz;paramgauss], x) + var*rand(X, &quot;normal&quot;);

// **********
// Programme principal
// **********

[S, Aopt] = leastsq(list(residus, X, Y), Ainit)
Yopt = profil(Aopt, X);
YLopt = lorentz(Aopt(1:2),X);
YGopt = gauss(Aopt(3:4),X);

// affichage

plot(X, Yopt, &quot;-r&quot;)
plot(X, YLopt, &quot;-c&quot;)
plot(X, YGopt, &quot;-g&quot;)
plot(X, Y, &quot;+b&quot;)

hauteur = paramlorentz(1)+paramgauss(1);

xstring(-demielargeur, hauteur,...
 &quot;lorentzienne : Al = &quot;+string(0.01*round(100*Aopt(1)))...
+&quot; ; Hl = &quot;+string(0.01*round(100*Aopt(2))))
xstring(-demielargeur, 3*hauteur/4,...
 &quot;gaussienne : Ag = &quot;+string(0.01*round(100*Aopt(3)))...
+&quot; ; Hg = &quot;+string(0.01*round(100*Aopt(4))))
xstring(-demielargeur, hauteur/2,...
 &quot;variance : S = &quot;+string(0.01*round(100*S))))
&lt;/syntaxhighlight&gt;

L'algorithme par défaut de &lt;code&gt;leastsq()&lt;/code&gt; est l'algorithme de pseudo-Newton. On peut aussi utiliser l'[[w:Méthode du gradient conjugué|algorithme du gradient conjugué]] en ajoutant &lt;code&gt;&quot;gc&quot;&lt;/code&gt; aux paramètres, ou bien algorithme foncitonnant avec les fonctions non-différentiables avec &lt;code&gt;&quot;nd&quot;&lt;/code&gt;. On peut enfin utiliser la commande &lt;code&gt;lsqrsolve()&lt;/code&gt;, qui utilise l'algorithme de Levenberg-Marquardt.

== Notes ==

{{références}}

----
''[[Découvrir Scilab/Interpolation, extrapolation et lissage|Interpolation, extrapolation et lissage]]'' &amp;lt; [[Découvrir Scilab|↑]] &amp;gt; ''[[Découvrir Scilab/Calcul différentiel et intégral|Calcul différentiel et intégral]]''

[[Catégorie:Découvrir Scilab (livre)|Regression]]</text>
      <sha1>0z5vzyi485vxsuiiwatioeli2txoeg8</sha1>
    </revision>
  </page>
  <page>
    <title>Python pour le calcul scientifique/Annexe/Index</title>
    <ns>0</ns>
    <id>83349</id>
    <revision>
      <id>769276</id>
      <parentid>768707</parentid>
      <timestamp>2026-07-01T07:02:55Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>.append(), .pop(), .remove()</comment>
      <origin>769276</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17195" sha1="1estf9pl6gcatywabapk8hsnutdzs24" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes_et_n-uplets|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes_et_n-uplets|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes_et_n-uplets|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>1estf9pl6gcatywabapk8hsnutdzs24</sha1>
    </revision>
    <revision>
      <id>769279</id>
      <parentid>769276</parentid>
      <timestamp>2026-07-01T07:06:54Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>liens plus précis</comment>
      <origin>769279</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17159" sha1="3qrgzagq3qkmbo2lsgexojnsgzbb6hn" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>3qrgzagq3qkmbo2lsgexojnsgzbb6hn</sha1>
    </revision>
    <revision>
      <id>769280</id>
      <parentid>769279</parentid>
      <timestamp>2026-07-01T07:09:35Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* D */ del()</comment>
      <origin>769280</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17237" sha1="88eo1ypk8i0vv5llb59h0e7nz9aiesl" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>88eo1ypk8i0vv5llb59h0e7nz9aiesl</sha1>
    </revision>
    <revision>
      <id>769282</id>
      <parentid>769280</parentid>
      <timestamp>2026-07-01T07:16:31Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* S */ .sort()</comment>
      <origin>769282</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17321" sha1="h8ortxtuh8pz5360piiqqbyn23xjez5" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>h8ortxtuh8pz5360piiqqbyn23xjez5</sha1>
    </revision>
    <revision>
      <id>769285</id>
      <parentid>769282</parentid>
      <timestamp>2026-07-01T07:19:42Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* L */ list()</comment>
      <origin>769285</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17400" sha1="3gwf46chnsxzd93kokui7nq3ikyzjlv" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>3gwf46chnsxzd93kokui7nq3ikyzjlv</sha1>
    </revision>
    <revision>
      <id>769288</id>
      <parentid>769285</parentid>
      <timestamp>2026-07-01T07:33:16Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* S */ sorted()</comment>
      <origin>769288</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17484" sha1="69rx0u6nnf65rnzqqh6m87tsi785lxl" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>69rx0u6nnf65rnzqqh6m87tsi785lxl</sha1>
    </revision>
    <revision>
      <id>769290</id>
      <parentid>769288</parentid>
      <timestamp>2026-07-01T07:57:09Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* I */ iter</comment>
      <origin>769290</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17566" sha1="i24is5c02o7wtv0pyza0l9am4opbnf1" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>i24is5c02o7wtv0pyza0l9am4opbnf1</sha1>
    </revision>
    <revision>
      <id>769291</id>
      <parentid>769290</parentid>
      <timestamp>2026-07-01T07:57:38Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* R */ reversed</comment>
      <origin>769291</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17652" sha1="nhcavq6ytuscyf0qqg78e98kuv4qqih" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;reversed()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>nhcavq6ytuscyf0qqg78e98kuv4qqih</sha1>
    </revision>
    <revision>
      <id>769292</id>
      <parentid>769291</parentid>
      <timestamp>2026-07-01T07:58:09Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* * */ __next__()</comment>
      <origin>769292</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17747" sha1="gl5at3b2fzb1a5ite7bpqj4jdcun6xi" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;iterator.__next__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;reversed()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>gl5at3b2fzb1a5ite7bpqj4jdcun6xi</sha1>
    </revision>
    <revision>
      <id>769294</id>
      <parentid>769292</parentid>
      <timestamp>2026-07-01T07:59:29Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* * */ __call__()</comment>
      <origin>769294</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17842" sha1="0jab1xsrcyatjws242wiltnb2z6i8wj" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;callable.__call__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Appelable|1]]
* &lt;code&gt;iterator.__next__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;reversed()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>0jab1xsrcyatjws242wiltnb2z6i8wj</sha1>
    </revision>
    <revision>
      <id>769296</id>
      <parentid>769294</parentid>
      <timestamp>2026-07-01T08:11:18Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>/* * */ _</comment>
      <origin>769296</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17982" sha1="lrmdmcxt393xmshgtt1kgrl8l6e0zc2" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;_&lt;/code&gt; (tiret d esoulignement, ''{{lang|en|underscore}}'') : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;callable.__call__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Appelable|1]]
* &lt;code&gt;iterator.__next__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;reversed()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>lrmdmcxt393xmshgtt1kgrl8l6e0zc2</sha1>
    </revision>
    <revision>
      <id>769297</id>
      <parentid>769296</parentid>
      <timestamp>2026-07-01T08:12:07Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* * */</comment>
      <origin>769297</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="18049" sha1="lp8ns53kklnp5ytof4ql82b7eelmtre" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;_&lt;/code&gt; (tiret de soulignement, ''{{lang|en|underscore}}'') : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]], [[../../Éléments_de_programmation#Substitution_de_variables|2]]
* &lt;code&gt;callable.__call__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Appelable|1]]
* &lt;code&gt;iterator.__next__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;reversed()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>lp8ns53kklnp5ytof4ql82b7eelmtre</sha1>
    </revision>
    <revision>
      <id>769298</id>
      <parentid>769297</parentid>
      <timestamp>2026-07-01T08:13:04Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* * */</comment>
      <origin>769298</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="18029" sha1="dcd5k7g1rjmmldo9n6q9tpo8avgbz1n" xml:space="preserve">{{SommaireCompact}}

== * ==
* &lt;code&gt;+&lt;/code&gt; (plus) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;+=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;-&lt;/code&gt; (moins) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|3]]
* &lt;code&gt;-=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;*&lt;/code&gt; (astérisque) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;**&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;/&lt;/code&gt; (barre de fraction) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;//&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;^&lt;/code&gt; (circonflexe) : [[../../Découverte_de_Python_et_de_Jupyter#cite_note-2|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;&lt;/code&gt; (esperluette) : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;&amp;=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;|&lt;/code&gt; (tube) : [[../../Découverte de Python et de Jupyter#Les booléens|1]],  [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|2]]
* &lt;code&gt;|=&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les booléens|1]]
* &lt;code&gt;_&lt;/code&gt; (tiret de soulignement, ''{{lang|en|underscore}}'') : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]], [[../../Éléments_de_programmation#Substitution_de_variables|2]]
* &lt;code&gt;callable.__call__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Appelable|1]]
* &lt;code&gt;iterator.__next__()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== A ==
* &lt;code&gt;plt.add_subplot()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axis.add_patch()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* aléatoire (générateur de nombres pseudo-~) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Graphiques|2]], [[../../Polynômes#Régression polynomiale|3]], [[../../Statistiques#Fréquence, histogramme|'''4''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]], [[../../Régression et optimisation#Régression linéaire|6]]
* &lt;code&gt;and&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]], [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|2]] &lt;br /&gt;voir [[#*|&amp;]], [[#L|np.logical_all()]]
* &lt;code&gt;all&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]
* &lt;code&gt;list.append()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;axes.annotate()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;np.arange()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Premier_tracé_graphique|1]], [[../../Éléments_de_programmation#Définition_en_compréhension|2]], [[../../Graphiques|3]], [[../../Manipulation_de_matrices#Définir_un_tenseur|'''3''']]&lt;br /&gt; → [[#R|&lt;code&gt;range()&lt;/code&gt;]]
* &lt;code&gt;np.array()&lt;/code&gt; (classe &lt;code&gt;ndarray&lt;/code&gt;) : [[../../Fonctions_mathématiques_générales#Vecteurs_et_matrices|1]], [[../../Éléments_de_programmation#Exploiter_le_contenu_d'un_fichier_texte|2]], [[../../Graphiques#Transformation_des_objets_graphiques|3]], [[../../Manipulation_de_matrices|'''4''']], [[../../Statistiques#Méthodes_de_matrices|5]], [[../../Algèbre_linéaire#Opérations_vectorielles|6]]
* &lt;code&gt;float.as_integer_ratio()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]], [[../../Éléments_de_programmation#Réels|2]]
* &lt;code&gt;fig.axes&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]

== B ==
* &lt;code&gt;plt.bar()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* booléens : [[../../Découverte de Python et de Jupyter#Les booléens|1]], [[../../Fonctions mathématiques générales#Fonctions booléennes|2]]
* &lt;code&gt;break()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== C ==
* ''{{lang|en|callable}}'' (« appelable ») : [[../../Découverte_de_Python_et_de_Jupyter#Appelable_(callable)|1]]
* &lt;code&gt;str.capitalize()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.center()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;chr()&lt;/code&gt; : [[../../Éléments_de_programmation#Autres_fonctions|1]]
* classe (d'un langage orienté objet) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* &lt;code&gt;color&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;fig.colorbar()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* complexe (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* compréhension (définition en) : [[../../Éléments_de_programmation#Définition_en_compréhension|1]]
* &lt;code&gt;itertools.compress()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;plt.contour()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;plt.contourf()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;continue()&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== D ==
* &lt;code&gt;def&lt;/code&gt; : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;del()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* division euclidienne : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;divmode()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;dpi&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]

== E ==
* &lt;code&gt;edgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;elif&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;else&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* &lt;code&gt;enumerate()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* espace de nom (&lt;code&gt;np.&lt;/code&gt;, &lt;code&gt;plt.&lt;/code&gt;, &lt;code&gt;scipy.&lt;/code&gt;…) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]], [[../../Découverte_de_Python_et_de_Jupyter#Les_espaces_de_noms|2]]

== F ==
* &lt;code&gt;facecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;figsize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;fillstyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;str.find()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* fonction (définir une ~) : [[../../Éléments_de_programmation#Fonction|1]]
* &lt;code&gt;for&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== G ==
* &lt;code&gt;plt.gca()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* &lt;code&gt;plt.gcf()&lt;/code&gt; : [[../../Graphiques#Styles_de_codage_«_pyplot_»_et_«_OO_»|1]]
* GIF animé : [[../../Graphiques#Créer_un_GIF_animé|1]]

== H ==
* &lt;code&gt;plt.hist()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;html&lt;/code&gt; (module) : [[../../Découverte_de_Python_et_de_Jupyter#Les_chaînes_de_caractères|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]]

== I ==
* &lt;code&gt;if&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]
* imaginaire (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;in&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Les ensembles et les dictionnaires|1]], [[../../Éléments de programmation#Définition en compréhension|2]]
* infini +∞, &lt;code&gt;float(&quot;inf&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* instance (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* installation d'un module : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* &lt;code&gt;is&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Les_booléens|1]]
* &lt;code&gt;str.isdigit()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;float.is_integer()&lt;/code&gt; : [[../../Éléments_de_programmation#Réels|1]]
* &lt;code&gt;iter()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* itérable : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

== J ==
* &lt;code&gt;j&lt;/code&gt; (imaginaire) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]

== L ==
* LaTeX : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* &lt;code&gt;layout&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_de_la_figure|1]]
* &lt;code&gt;plt.legend()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|2]]
* &lt;code&gt;linear&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;linestyle&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;linewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;list()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.ljust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;log&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;np.logical_and()&lt;/code&gt; : [[../../Fonctions_mathématiques_générales#Fonctions_booléennes|1]]&lt;br /&gt; voir [[#A|and]]
* &lt;code&gt;logit&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;str.lower()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;ls&lt;/code&gt; (paramètre) : voir ''linestyle''
* &lt;code&gt;lw&lt;/code&gt; (paramètre) : voir ''linewidth''

== M ==
* &lt;code&gt;marker&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markeredgewidth&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markerfacecolor&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;markersize&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* Matplotlib (module, &lt;code&gt;np&lt;/code&gt;) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]&lt;br /&gt;→ [[#P|Pyplot]]
* &lt;code&gt;np.matrix()&lt;/code&gt; (déprécié) : [[../../Manipulation_de_matrices#Différence_entre_array_et_matrix|1]], [[../../Algèbre_linéaire#Opérations_vectorielles|2]]&lt;br /&gt;→ [[#A|&lt;code&gt;np.array()&lt;/code&gt;]]
* &lt;code&gt;np.meshgrid()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* méthode (d'une classe) : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]
* module : [[../../Découverte_de_Python_et_de_Jupyter#Vocabulaire|1]]

== N ==
* NaN ''(not a number)'', &lt;code&gt;float(&quot;nan&quot;)&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Commandes_élémentaires|1]]
* &lt;code&gt;nextafter()&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]]
* &lt;code&gt;normal()&lt;/code&gt; [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|5]]
* &lt;code&gt;np.&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;numpy.&lt;/code&gt;&lt;br /&gt;→ Numpy
* Numpy (module) : [[../../Découverte de Python et de Jupyter|1]]

== P ==
* &lt;code&gt;str.partition()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* ''patch'' (pièce, dessin) : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;plt.pcolormesh()&lt;/code&gt; : [[../../Graphiques#Cartes_de_valeurs_et_de_vecteurs|1]]
* &lt;code&gt;pip install&lt;/code&gt; : [[../../Découverte de Python et de Jupyter#Installation et mise à jour de modules|1]]
* PIL (module ''Python imaging library'') : [[../../Graphiques#Créer_un_GIF_animé|1]]
* &lt;code&gt;plt.plot()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;plt.plot_surface()&lt;/code&gt; : [[../../Graphiques#Surfaces_3D|1]]
* &lt;code&gt;plt&lt;/code&gt; : espace de nom, abréviation de &lt;code&gt;pyplot.&lt;/code&gt;&lt;br /&gt;→ &lt;code&gt;plt&lt;/code&gt;
* &lt;code&gt;plt.polar()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;list.pop()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;pow()&lt;/code&gt; : [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|1]]
* puissance (élévation à la) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]], [[../../Fonctions mathématiques générales#Rappel sur les opérations de base|2]]
* &lt;code&gt;pyplot&lt;/code&gt; (&lt;code&gt;plt&lt;/code&gt;, option de Matplotlib) : [[../../Découverte de Python et de Jupyter#Premier tracé graphique|1]], [[../../Graphiques|2]]
* PyQt (module) : [[../../Éléments_de_programmation#Avec_PyQt|1]]

== Q ==
* &lt;code&gt;plt.quiver()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]

== R ==
* &lt;code&gt;rand()&lt;/code&gt; : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']]
* &lt;code&gt;randn()&lt;/code&gt; : [[../../Graphiques|1]], [[../../Polynômes#Régression polynomiale|2]], [[../../Statistiques#Fréquence, histogramme|'''3''']], [[../../Régression et optimisation#Régression linéaire|4]]
* &lt;code&gt;random&lt;/code&gt; (module NumPy) : [[../../Éléments de programmation#Utilisation de Pandas|1]], [[../../Statistiques#Fréquence, histogramme|'''2''']], [[../../Interpolation, extrapolation et lissage#Avec le module scipy.signal|3]]
* &lt;code&gt;range()&lt;/code&gt; : [[../../Premiers programmes#Deuxième_programme|1]], [[../../Éléments_de_programmation#Autres_fonctions|2]], [[../../Éléments_de_programmation#Définition_en_compréhension|3]], [[../../Éléments_de_programmation#Structures_de_contrôle|4]]&lt;br /&gt; → [[#A|&lt;code&gt;np.arange()&lt;/code&gt;]]
* &lt;code&gt;plt.rcParams()&lt;/code&gt; : [[../../Graphiques#Mise_en_forme_du_texte|1]]
* réel à virgule flottante (nombre) : [[../../Découverte de Python et de Jupyter#Commandes élémentaires|1]]
* &lt;code&gt;list.remove()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;str.replace()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;reversed()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.rfind()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;str.rjust()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== S ==
* &lt;code&gt;plt.savefig()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;line2D.set()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;axis.set_aspect()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;line2D.set_label()&lt;/code&gt;[[../../Graphiques#Plusieurs_courbes_sur_un_même_système_d'axes|1]]
* &lt;code&gt;line2D.set_linestyle()&lt;/code&gt; (paramètre) : [[../../Graphiques#Mise_en_forme_d'une_courbe|1]]
* &lt;code&gt;axes.set_rticks()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_thetagrids()&lt;/code&gt; : [[../../Graphiques#Tracé_polaire|1]]
* &lt;code&gt;axes.set_title()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axes.set_xlabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_xlim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_xsticks()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* &lt;code&gt;axes.set_ylabel()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;axis.set_ylim()&lt;/code&gt; : [[../../Graphiques#Dessins|1]]
* &lt;code&gt;axis.set_minor_formatter()&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]
* ''shebang'' : [[../../Découverte de Python et de Jupyter|1]]
* &lt;code&gt;plt.show()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;list.sort()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Listes|1]]
* &lt;code&gt;sorted()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]
* &lt;code&gt;str.split()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]
* &lt;code&gt;plt.step()&lt;/code&gt; : [[../../Graphiques#Autres_exemples_de_tracés_2D|1]]
* &lt;code&gt;plt.subplots()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;fig.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;plt.suptitle()&lt;/code&gt; : [[../../Graphiques#Exemple|1]]
* &lt;code&gt;symlog&lt;/code&gt; (paramètre) : [[../../Graphiques#Gestion_des_échelles|1]]

== T ==
* &lt;code&gt;plt.text()&lt;/code&gt; : [[../../Graphiques#Annotations|1]]
* &lt;code&gt;plt.title()&lt;/code&gt; : [[../../Graphiques|1]]
* &lt;code&gt;aix.transData()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;transform&lt;/code&gt; (paramètre) : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* &lt;code&gt;matplotlib.transforms()&lt;/code&gt; : [[../../Graphiques#Transformation_des_objets_graphiques|1]]
* Tk (module) : [[../../Éléments_de_programmation#Avec_Tk|1]]

== U ==
* &lt;code&gt;str.upper()&lt;/code&gt; : [[../../Éléments_de_programmation#Méthodes_des_chaînes|1]]

== W ==
* &lt;code&gt;where()&lt;/code&gt; : [[../../Manipulation_de_matrices#Trouver_une_valeur|1]]
* &lt;code&gt;while&lt;/code&gt; : [[../../Éléments_de_programmation#Structures_de_contrôle|1]]

== X ==
* &lt;code&gt;plt.xlabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Y ==
* &lt;code&gt;plt.ylabel()&lt;/code&gt; : [[../../Graphiques|1]]

== Z ==
* &lt;code&gt;zip()&lt;/code&gt; : [[../../Découverte_de_Python_et_de_Jupyter#Itérable|1]]

----
[[../../Traitement d'images|Traitement d'images]] &amp;lt; [[../../|↑]] &amp;gt;

[[Catégorie:Python pour le calcul scientifique (livre)]]</text>
      <sha1>dcd5k7g1rjmmldo9n6q9tpo8avgbz1n</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Discipline philosophique</title>
    <ns>14</ns>
    <id>83477</id>
    <revision>
      <id>769259</id>
      <parentid>764926</parentid>
      <timestamp>2026-07-01T03:58:29Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769259</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="26" sha1="0lxbnq4i4v1nqloofp2gm9eqtcz6p4t" xml:space="preserve">[[catégorie:Philosophie]]</text>
      <sha1>0lxbnq4i4v1nqloofp2gm9eqtcz6p4t</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Théorie de la connaissance</title>
    <ns>14</ns>
    <id>84029</id>
    <revision>
      <id>769256</id>
      <timestamp>2026-07-01T03:52:18Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <comment>Page créée avec « [[Catégorie:Discipline philosophique]] »</comment>
      <origin>769256</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39" sha1="08d5py569n2prl4un6bob6eoalb349u" xml:space="preserve">[[Catégorie:Discipline philosophique]]</text>
      <sha1>08d5py569n2prl4un6bob6eoalb349u</sha1>
    </revision>
    <revision>
      <id>769257</id>
      <parentid>769256</parentid>
      <timestamp>2026-07-01T03:53:36Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <origin>769257</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="70" sha1="4b6w0oljebqo5w53l5xas5cnxcvf4ee" xml:space="preserve">[[Catégorie:Discipline philosophique]]
[[Catégorie:Épistémologie]]</text>
      <sha1>4b6w0oljebqo5w53l5xas5cnxcvf4ee</sha1>
    </revision>
  </page>
  <page>
    <title>Catégorie:Théorie de la connaissance (livre)</title>
    <ns>14</ns>
    <id>84030</id>
    <revision>
      <id>769261</id>
      <timestamp>2026-07-01T03:59:19Z</timestamp>
      <contributor>
        <username>PandaMystique</username>
        <id>119061</id>
      </contributor>
      <comment>Page créée avec « [[Catégorie:Théorie de la connaissance]] »</comment>
      <origin>769261</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42" sha1="pl8jnaif3ptgdi54cc2qivsnggbc5bk" xml:space="preserve">[[Catégorie:Théorie de la connaissance]]</text>
      <sha1>pl8jnaif3ptgdi54cc2qivsnggbc5bk</sha1>
    </revision>
  </page>
</mediawiki>