OpenLLM-France/wikimedia huggingface dataset:
# PyQt/QMainWindow
## Description

Cette classe représente une fenêtre principale d'une application, pouvant contenir entre autre une barre de menus, une zone pour les barres d'outils et une barre de statuts. Cette fenêtre est généralement utilisée pour fournir l'accès à un widget central comme par exemple une zone d'édition de texte, une zone de dessin ou un espace de travail (QWorkspace) pour les applications comportant plusieurs fenêtres. Afin d'ajouter simplement des menus et barres d'outils à une fenêtre, il suffit d'appeler le constructeur du widget voulu en lui passant la fenêtre comme paramètre pour le parent. Ce widget supporte aussi les « fenêtres crochantes », à savoir que vous pouvez avoir plusieurs éléments graphiques dans la fenêtre principale et les positionner à votre guise. Vu la multitude de possibilités offertes par ce widget nous ne pouvons que vous conseiller de consulter la documentation de référence à l'adresse http://qt-project.org/doc/qt-4.8/qmainwindow.html. Vous trouverez aussi sur cette page quelques extraits de code (C++) vous montrant la mise en œuvre de certaines fonctionnalités.

## Exemple

* PyQt3.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qmainwindow.py
* # Programme exemple pour la classe QMainWindow
* from qt import *
* import sys
* class Demo(QApplication) :
* def init (self, args) :
* QApplication. init (self,args)
* # widget principal, il s'agit d'une fenêtre de dialogue
* self.main = QMainWindow(None, "mainwindow")
* self.main.setCaption("Demo QMainWindow")
* self.main.resize(640,480)
* #widget central : QTextEdit
* self.edit = QTextEdit(self.main, "editor")
* self.edit.setFocus
* self.main.setCentralWidget(self.edit)
* # ajout facile d'éléments dans la barre de menu
* # NOTE : crée la barre s'il n'existe pas
* self.main.menuBar.insertItem("New")
* self.main.menuBar.insertItem("Quit")
* # changement du message de status
* # NOTE : crée la zone de status si inexistante
* self.main.statusBar.message("Demo en cours", 200000)
* self.main.show
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.exec loop
* if name == "__main__" :
* app=Demo(sys.argv)
* PyQt4.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qmainwindow.py
* # Programme exemple pour la classe QMainWindow
* from PyQt4.QtGui import *
* from PyQt4.QtCore import *
* import sys
* class Demo(QApplication) :
* def __init__(self, args) :
* QApplication.__init__(self,args)
* # widget principal, il s'agit d'une fenêtre de dialogue
* self.main = QMainWindow
* self.main.setWindowTitle("Demo QMainWindow")
* self.main.resize(640,480)
* #widget central : QTextEdit
* self.edit = QTextEdit("editor", self.main)
* self.edit.setFocus
* self.main.setCentralWidget(self.edit)
* # ajout facile d'éléments dans la barre de menu
* # NOTE : crée la barre s'il n'existe pas
* self.main.menuBar.addAction("New")
* self.main.menuBar.addAction("Quit")
* # changement du message de status
* # NOTE : crée la zone de status si inexistante
* self.main.statusBar.showMessage("Demo en cours", 10000)
* self.main.show
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.exec_
* if __name__ == "__main__" :
* app=Demo(sys.argv)
# PyQt/QAction & QActionGroup
## Description

La classe QAction définit un modèle abstrait permettant de représenter une action sur l'interface. Elle peut être utilisée dans une entrée d'un menu ou par l'intermédiaire d'une barre d'outils. La classe QActionGroup permet quant à elle de regrouper un ensemble d'actions qui doivent être exclusives entre elles.
Dans les interfaces utilisateur les commandes peuvent être invoquées par des menus déroulants, des barres d'outils ou des raccourcis clavier. Il n'est pas rare qu'il existe des actions identiques pouvant être invoquées par différents éléments de l'interface, et que ces éléments doivent rester synchronisés. Il est donc utile de représenter ces commandes comme des actions, puis d'ajouter ces actions aux divers éléments de l'interface.
Prenons un exemple : dans un éditeur de texte, l'utilisateur a la possibilité de mettre du texte en gras. Pour cela, il dispose d'une action dans un menu déroulant, d'un bouton dans une barre d'outils et d'un raccourci clavier. En utilisant une action représentant la mise en gras du texte, non seulement on factorise le code, mais en plus cela nous permet lorsque l'utilisateur utilise le raccourci clavier de mettre le bouton de la barre d'outils dans l'état activé. Un objet QAction peut contenir une icône, du texte, une touche accélératrice (raccourci clavier), un texte d'aide (WhatsThis) et un texte pour l'info-bulle. La plupart de ces données peuvent être chargées par l'intermédiaire du constructeur, mais il est aussi possible d'utiliser des méthodes spécifiques pour les modifier.
Les actions peuvent être de deux types : les actions à état (« toggle action »), et les commandes. Une action à état est par exemple le changement d'un texte en gras ou en normal, tandis qu'une commande peut par exemple représenter l'ouverture d'une fenêtre de sélection de fichier. Seules les actions à état émettent le signal toggled tandis que les deux types d'actions émettent le signal activated. Les actions peuvent être ajoutées aux éléments graphiques avec la méthode addTo tandis qu'elles peuvent être supprimées par l'intermédiaire de l'appel à removeFrom.

## Exemple

Il est très difficile de trouver un exemple mettant en œuvre ces deux classes. Cependant, vous pouvez consulter le code de la section Qt Designer dans laquelle, à partir d'une interface générée avec l'utilitaire Qt Designer, nous créons une petite application. Au sein de cette application nous avons utilisé la classe QAction.
# PyQt/QDialog
## Description

La classe QDialog représente une fenêtre de dialogue. Une telle fenêtre est généralement utilisée pour de courtes actions et des communications brèves avec l'utilisateur. Cette fenêtre peut être modale ou non, avoir un bouton par défaut et retourner une valeur.
Une fenêtre modale est une fenêtre bloquant toute interaction de l'utilisateur sur d'autres éléments graphiques de l'application pendant tout le temps ou la fenêtre est active. À l'inverse, une fenêtre non-modale permet à l'utilisateur de continuer à interagir avec le reste des éléments graphiques. Cette propriété peut être modifiée par l'appel à une méthode ou bien être mise en place directement dans le constructeur de la classe. Le bouton par défaut est le bouton qui sera activé lorsque l'utilisateur appuie sur la touche « Entrée » du clavier. De même, lorsque l'utilisateur appuie sur la touche « Echap », la fenêtre se ferme et met le code Rejected dans sa valeur de retour. Il existe plusieurs sous-classes à QDialog, permettant de créer des types de dialogues prédéfinis :
* QColorDialog : fenêtre de sélection d'une couleur ;
* QErrorMessage : fenêtre pour un message d'erreur ;
* QFileDialog : dialogue de sélection de fichier :
* QFontDialog : dialogue de sélection de police de caractères ;
* QInputDialog : fenêtre permettant de demander une valeur à l'utilisateur ;
* QMessageBox : boîte de message modale avec une icône, un message et des boutons ;
* QProgressDialog : fenêtre contenant une barre de progression ;
* QTabDialog : fenêtre avec de multiples onglets ;
* QWizard : fenêtre permettant de mettre en place facilement un assistant pour aider l'utilisateur.

## Exemple

* PyQt3.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qdialog.py
* # Programme exemple pour la classe QDialog
* from qt import *
* import sys
* class Demo(QApplication) :
* def init (self,args) :
* QApplication. init (self, args)
* # dialogue de sélection de fichier
* s = QFileDialog.getOpenFileName("", "", None, "Boite d'ouverture de fichier", "Choisissez un fichier")
* # conversions nécessaires entre QString et le type str de python
* h = QString("<h1>Vous avez choisi le fichier</h1>\n<i>")
* h.append(s)
* h.append("</i>")
* # message d'information sur le fichier séléctionné
* QMessageBox.information(None, "Fichier choisi", h)
* if name == "__main__" :
* x = Demo(sys.argv)
* PyQt4.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qdialog.py
* # Programme exemple pour la classe QDialog
* from PyQt4.QtCore import *
* from PyQt4.QtGui import *
* import sys
* class Demo(QApplication) :
* def __init__ (self,args) :
* QApplication.__init__(self, args)
* # dialogue de sélection de fichier
* s = QFileDialog.getOpenFileName(None, "Boite d'ouverture de fichier")
* # conversions nécessaires entre QString et le type str de python
* h = QString("<h1>Vous avez choisi le fichier</h1>\n<i>")
* h.append(s)
* h.append("</i>")
* # message d'information sur le fichier sélectionné
* QMessageBox.information(None, "Fichier choisi", h)
* if __name__ == "__main__" :
* x = Demo(sys.argv)

## Références

* ↑ anglais http://qt-project.org/doc/qt-4.8/qdialog.html
# PyQt/Présentation de la librairie
## La librairie Qt

Qt est une bibliothèque logicielle offrant essentiellement des composants d'interface graphique (communément appelés widgets), mais également d'autres composants non-graphiques permettant entre autre l'accès aux données, les connexions réseaux, la gestion des files d'exécution, etc. Elle a été développée en C++ par la société Trolltech et est disponible pour de multiples environnements Unix utilisant X11 (dont Linux), Windows et Mac OS. Qt est un toolkit qui présente de nombreux avantages. Il est intéressant de les souligner puisque ces avantages se retrouvent dans PyQt.
* Toolkit graphique complet en C++
** il est relativement simple à utiliser ;
** il offre de nombreux outils et extensions ;
** ce toolkit est disponible gratuitement pour Unix ;
** il constitue la base de l'environnement KDE.
* Multiplateformes
** disponible pour Unix, Windows et Mac OS X;
** look and feel natif
** les applications présentent l'apparence des systèmes d'exploitations sur lesquels elles tournent par défaut, mais il est possible d'installer un autre look and feel, même lors de l'exécution ;
** il est implémenté sur les couches basses des systèmes graphiques.
* Caractéristiques, extensions, outils
** internationalisation ;
** OpenGL multiplateformes ;
** base de données SQL ;
** générateur d'interfaces Qt Designer.

## PyQt

PyQt est un module qui permet de lier le langage Python avec la bibliothèque Qt. Il permet ainsi de créer des interfaces graphiques en python. Une extension de QtDesigner (utilitaire graphique de création d'interfaces Qt) permet de gérer le code python d'interfaces graphiques. PyQt dispose de tous les avantages lié à Qt.

## Versions utilisées dans ce guide

À l'heure où nous terminons d'écrire ce guide la librairie PyQt permettant d'utiliser Qt en version 4 vient de sortir d'une longue phase de développement. Nous avons donc rédigé ce guide en utilisant la version 3.15 de la librairie, permettant d'utiliser Qt en version 3. Qt 4 apporte quelques changements importants dans la gestion des éléments graphiques, avec de nouvelles possibilités fort intéressantes. Nous vous laissons consulter la documentation de référence de Qt ainsi que de PyQt pour voir les différences avec la version 3 de ce guide.
# PyQt/QApplication
## Description

La classe QApplication s'occupe de gérer l'ensemble des paramètres et des affichages d'une application Qt. Elle contient entre autre la boucle principale de traitement des événements.
Cette boucle est une boucle infinie à mettre à la fin de votre code afin que votre programme fonctionne et traite les événements de l'utilisateur ou des objets internes. Il est important de noter que pour chaque application Qt il y a une et une seule instance de QApplication, qu'il y ait 0, 1, 2 ou plus de fenêtres dans votre application. De plus, l'objet QApplication s'occupant d'initialiser l'ensemble de l'application (voir le paragraphe suivant pour plus de détails), il est important qu'il soit créé avant tout autre objet ayant un rapport avec l'interface. Voici les responsabilités de QApplication :
* initialisation de l'application avec les préférences du bureau ; entre autres, palette de couleurs, polices de caractère, intervalle du double clic ; ces éléments sont mis à jour automatiquement lorsque l'utilisateur change les paramètres de son bureau ;
* gestion des événements venant du système d'exploitation et envoi de ces événements aux bons widgets (par exemple un clic de souris sur un bouton) ;
* parcours des arguments passés à l'exécutable et changement des variables internes en accord avec ces paramètres (par exemple style graphique de l'application) ;
* définition du look de l'application (en rapport avec le point précédent) ;
* localisation des chaînes de caractères (si le programme gère la traduction des éléments) ;
* connaissance de l'ensemble des éléments graphiques de l'application ; utile si vous désirez récupérer la position d'un widget ou connaître le widget qui est situé à une certaine position ;
* gestion du curseur de la souris en fonction de l'élément sur lequel il se trouve ;
* sur le système X-Window, met à disposition des méthodes permettant de gérer la communication avec le serveur d'affichage ;
* gestion des sessions ; permet de terminer correctement l'application lorsqu'un utilisateur se déconnecte du système, d'annuler un arrêt du système si l'application ne peut pas se terminer, et de conserver l'état de l'application pour une future utilisation.
L'ensemble des ces fonctions peuvent être modifiées ou utilisées par l'appel à des méthodes sur l'objet de type QApplication. Pour cela nous vous laissons consulter la documentation de référence de la classe à l'adresse http://qt-project.org/doc/qt-4.8/qapplication.html.

## Exemple

Nous vous laissons consulter les autres exemples de ce guide pour voir comment utiliser cette classe. En effet, vu son caractère obligatoire pour obtenir une application elle est utilisée dans tous nos exemples.
# Python pour le calcul scientifique/Traitement d'images

Rappelons que dorénavant les programmes commencent tous par :

## Charger et enregistrer une image

La manipulation des fichiers d'image peut se faire avec la bibliothèque imageio (image input/output, entrées et sorties d'images). La lecture d'un fichier se fait avec la fonction imageio.imread, qui transforme l'image en une matrice NumPy. L'écriture d'une matrice sous la forme d'un fichier d'image se fait avec la fonction imageio.imwrite.
L'affichage de la matrice sous forme d'image se fait avec la fonction plt.imshow.
Par exemple, téléchargeons l'image Husky puzzle book au format 320 × 240 (« 320px-Husky_puzzle_book.svg.png ») et mettons là dans le répertoire de travail. Puis :
Vous remarquerez que l'image originelle a une partie transparente (canal alpha) et que cela se transforme en noir dans l'image au format .bmp.
Nous pouvons également utiliser la bibliothèque PIL (Python imaging library, bibliothèque d'imagerie Python), et en particulier sa section Image. Elle contient la fonction PIL.Image.open qui permet de charger le fichier dans un objet d'une classe spécifique. Cette classe propose des méthodes dédiées comme .show pour montrer l'image et .save pour l'enregistrer.
On peut transformer cet objet en matrice NumPy avec la commande numpy.asarray. À l'inverse, on peut transformer une matrice NumPy en image PIL avec la commande PIL.Image.fromarray.
Par exemple :
Le module matplotlib dispose d'un bibliothèque image.

## Format des matrices

Les matrices images sont en fait des tenseurs d'ordre 3.
Si l'image est composée de L × l pixels, avec 16 millions de couleurs, et qu'il n'y a pas de canal alpha (pas de transparence), la matrice image est une matrice de dimension (L, l) dont chaque cellule est un vecteur de dimension 3. La cellule [i – 1, j – 1] contient la couleur du pixel (i, j) au format [R, V, B], chaque composante étant un nombre compris entre 0 et 255.
Par exemple :
S'il y a un canal alpha, alors chaque vecteur est de dimension 4. La cellule [i – 1, j – 1] contient la couleur du pixel (i, j) au format [R, V, B, A], la valeur A étant l'opacité cotée de 0 (totalement transparent) à 255 (totalement opaque). Par exemple :
Si le vecteur représentant un pixel n'a qu'une dimension (c'est donc un scalaire), alors la valeur est convertie en couleur selon la matrice de couleurs en cours (colormap). Pour avoir un rendu en niveaux de gris, il faut utiliser la fonction matplotlib.pyplot.gray. Par exemple :

## Fonctions spécifiques

* « Multidimensional image processing (scipy.ndimage) », sur docs.scipy.org (consulté le 28 juin 2022)

## Notes et références

* ↑ (en) « Imageio » (consulté le 28 juin 2022).
* ↑ Les fonctions scipy.misc.imread et scipy.misc.imsave sont obsolètes et ont été retirées en 2018.
* ↑ Par exemple dans sa version (en) « pillow » (consulté le 28 juin 2022).
* ↑ « matplotlib.image », sur Matplotlib.org (consulté le 14 avril 2023).
* ↑ Ou plus exactement 2$^{24}$ = 16 777 216 couleurs.
Calcul symbolique < ↑ >
# Pêcher un poisson

Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
Il existe différentes façons de pêcher un poisson : elles diffèrent en général en fonction du lieu.

## Pêcher en haute mer

* Pêcher en haute mer implique de nombreuses précautions et un matériel assez performant.Il faut s'enquérir de la météo, avoir un bateau qui permette l'autonomie pendant une période plus ou moins longue, un matériel de sauvetage, radar,...

## Pêcher à proximité des côtes

Pêche au carrelet

## Pêcher dans les cours d'eau

* soit en tendant un filet le long d'un cours d'eau, en ce cas le filet doit faire toute la longueur et toucher le fond (car les poissons y restent en général), soit en lançant un filet classique depuis la berge ou une barque.
** mais cette technique comporte des risques de déchirements, le fait que tous les déchets de la rivière viennent se cogner contre le filet et le rende visible, il faut bien sur rabattre les poissons d'un côté ou de l'autre ce qui nécessite une organisation particulière, les alevins ou les poissons trop jeunes peuvent s'y prendre, ce qui peut compromettre les espèces.
* à la ligne au moyen d'une canne à pèche (rustique) une tige d'arbre, un fil de pêche, un hameçon et un appât (ou professionnel) seul la nature de la canne à pêche change... en carbone ou aluminium.
# Python pour le calcul scientifique/Résolution d'équations

Rappelons que dorénavant les programmes commencent tous par :

## Système d'équations linéaires

Le sujet a été abordé dans le chapitre concernant l'algèbre linéaire.
    Pour plus de détails voir : Python pour le calcul scientifique/Algèbre linéaire.

## Équation polynomiale

La résolution d'une équation polynomiale consiste à trouver les racines de son polynôme. Par exemple, pour résoudre l'équation
    $x^{2}+3x+5=0$
nous pouvons utiliser :
    Pour plus de détails voir : Python pour le calcul scientifique/Polynômes.

## Équation différentielle

Le sujet est abordé dans le chapitre sur le calcul différentiel.
    Pour plus de détails voir : Python pour le calcul scientifique/Calcul différentiel et intégral.

## Équation quelconque

Une équation peut s'écrire de manière générale
    y = ƒ(x)
ce qui revient à résoudre
    ƒ(x) – y = 0.
Le module scipy.optimize propose la fonction root pour cela.
Par exemple, nous cherchons ci-dessous à résoudre x² + 5⋅sin x = 2
Le graphique nous montre qu'il existe une autre solution (x = –2,35). Nous pouvons trouver la trouver avec un point de départ différent, par exemple x0 = -5.
Cette méthode marche aussi pour des systèmes d'équations, en recherchant le vecteur nul. Considérons par exemple une poutre de section rectangulaire L × l, par exemple une planche de largeur L et de hauteur l. Sa raideur dépend du matériau dont elle est faite (bois, acier, aluminium…) mais aussi de sa forme ; la contribution de la forme à la raideur est exprimée par le moment quadratique I, exprimé en mm⁴ (si L et l sont en mm). Mise à plat, le moment quadratique vaut
    I$_1$ = L × l ³/12.
Mise à chant (c'est-à-dire posée sur la tranche), il vaut :
    I$_1$ = L³ × l /12.
Nous cherchons les dimensions L et l telles que I$_1$ = 200 000 mm⁴ et I$_2$ = 700 000 mm⁴. Pour cela, nous définissons le vecteur d'état X = ([L, l]) et la fonction moment quadratique I(X) = ([I1, I2]). Nous partons de dimensions a priori L = l = 50 mm. Nous cherchons donc à résoudre le système
    ${\begin{cases}\mathrm {L} \times l^{3}=200\,000\\\mathrm {L} ^{3}\times l=700\,000\end{cases}}$
par l'équation vectorielle
    $\operatorname {I} {\begin{pmatrix}\mathrm {L} \\l\end{pmatrix}}-{\begin{pmatrix}200\,000\\700\,000\end{pmatrix}}={\begin{pmatrix}0\\0\end{pmatrix}}.$
Il nous faut donc une planche de dimensions approximatives 63 × 34 mm².
    Pour plus de détails voir : Python pour le calcul scientifique/Régression et optimisation.

## Notes et références

Calcul différentiel et intégral < ↑ > Calcul symbolique
# Python pour le calcul scientifique/Sommaire

* Découverte de Python et de Jupyter
* Premiers programmes
* Fonctions mathématiques générales
* Éléments de programmation
* Graphiques
* Manipulation de matrices
* Polynômes
* Statistiques
* Interpolation, extrapolation et lissage
* Régression et optimisation
* Algèbre linéaire
* Calcul différentiel et intégral
* Résolution d'équations
* Calcul symbolique
* Traitement d'images
# Objective Caml/À faire
## Énumérations

Compréhension

## Entrées/sorties
### Affichage de texte

module Print

### Gestion de texte

Différents encodages (Unicode, Ascii, etc.)

## Génération de code durant la compilation

Camlp4

## Génération de code durant l'exécution ?

LLVM
# Objective Caml

* Wikipédia propose un article sur : « Programmation fonctionnelle ».
Ce wikilivre constitue une introduction à la programmation fonctionnelle à l'aide du langage OCaml (ou anciennement « Objective Caml »). Cette introduction est prévue pour des lecteurs ayant déjà manipulé un autre langage de programmation, sans forcément avoir beaucoup d'expérience, et si possible dotés d'une certaine curiosité mathématique. Il ne s'agit pas dans ce livre d'apprendre à accomplir une tâche précise mais d'apprendre la programmation fonctionnelle, les spécificités du langage OCaml, et comment s'en servir au mieux.
Pour en apprendre plus sur le langage OCaml et ses liens avec les autres langages, n'hésitez pas à lire l'article proposé par Wikipedia à ce sujet.
Note : ce wikilivre n'est pas une introduction au language Caml utilisées en classes préparatoires (Caml Light). Les concepts couverts sont identiques mais, outre les différences entre OCaml et Caml Light, il s'agit ici d'utiliser OCaml Batteries Included, une distribution d'Objective Caml plus complète que celle qui est employée durant les concours.

## Sommaire

* Une version imprimable du livre « Objective Caml » est disponible. (voir/ modifier)
* Une version PDF de ce livre est disponible.
* Introduction
* Bases
* Structures de données
* Programmes complets et modules
* Notes sur les chapitres à écrire
# Objective Caml/Sommaire

* Introduction
* Bases
* Structures de données
* Programmes complets et modules
* Notes sur les chapitres à écrire
# Objective Caml/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du wikilivre.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l'article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL : https://fr.wikibooks.org/wiki/Objective_Caml