Hyper complet ! Guide d'utilisation du cadre d'interface graphique Python PyQt5 !

Il n'y a pas beaucoup de logiciels qui utilisent Python pour développer des interfaces graphiques.Par rapport aux interfaces graphiques, les applications Web peuvent être plus populaires. Mais pour les gens comme moi qui ne sont pas familiers avec d'autres langages de programmation tels que C# ou WPF, ce n'est peut-être pas un bon outil.

Cadres d'interface graphique communs

• PyQt5 : Qt est une bibliothèque d'interface utilisateur graphique C++ multiplateforme. QT appartenait autrefois à Nokia et a ensuite été vendu à Digia Oyj, une société de logiciels finlandaise. PyQt5 est une interface Python basée sur Qt5 de Digia, qui consiste en un ensemble de modules Python. PyQt5 lui-même a plus de 620 classes et 6000 fonctions et méthodes. Il peut fonctionner sur plusieurs plates-formes, notamment : Unix, Windows et Mac OS.
• Pyside6 : Pyside est le package Python officiellement fourni par la société QT. La version précédente était Pyside2, qui correspond à QT5. Les règles de nommage de la dernière version ont été ajustées et remplacées par Pyside6, qui correspond à la version QT6. Étant donné que le produit officiel est plus optimiste, l'inconvénient est que la publication est relativement tardive et que les informations sur Internet ne sont pas aussi nombreuses que PyQt5.
• Tkinter : le framework d'interface graphique intégré de Python, implémenté à l'aide de TCL, et l'interpréteur TCL est intégré à Python. Lors de son utilisation, il n'est pas nécessaire d'installer des packages d'extension supplémentaires, et il peut être directement importé et multiplateforme. L'inconvénient est que la disposition de l'interface utilisateur est entièrement implémentée par code, et il n'y a que 15 composants couramment utilisés, et l'effet d'affichage est simple.
• PySimpleGUI : PySimpleGUI est un wrapper autour de Tkinter. L'implémentation d'une interface graphique personnalisée à l'aide de PySimpleGUI nécessite beaucoup moins de code que l'écriture de la même interface graphique directement à l'aide de Tkinter.
• WxPython : wxPython est une liaison du langage Python à la célèbre bibliothèque d'outils d'interface graphique multiplateforme wxWidgets. Il est largement utilisé, multiplateforme, écrit en C++ et contient peu de documents.Les utilisateurs peuvent avoir besoin de faire quelques ajustements au code de l'interface graphique dans différentes plateformes en fonction du contenu de programmation. Il n'est pas facile de résoudre le problème, le contrôle de la disposition du code n'est pas intuitif.
• Wax : Basé sur wxPython, un package conçu pour surmonter les problèmes de wxPython.
• Kivy : principalement pour les programmes multi-touch, les téléphones intelligents et les tablettes, etc., et peut également être utilisé sur des systèmes sans fonctions d'écran tactile, prise en charge complète de la plate-forme (Windows, Linux, Mac OS X, Android et iOS.) écrit en Python et cython, chinois Le support est médiocre, vous devez télécharger la bibliothèque chinoise et faire le chemin vous-même.
• BeeWare : écrivez une fois. Déployez partout. Besoin de travailler avec Kivy.
• Toga : une boîte à outils graphique pour le développement d'applications natives à l'aide de Python. Toga se compose d'une bibliothèque de composants de base avec une interface partagée pour simplifier le développement d'interfaces graphiques indépendantes de la plate-forme. Toga est disponible pour Mac OS, Windows, Linux (GTK) et les plates-formes mobiles telles qu'Android et iOS.
• Eel : une bibliothèque Python légère pour créer des applications graphiques HTML/JS hors ligne simples de type Electron (mais plus légères) avec un accès complet aux fonctionnalités et bibliothèques Python.
• Flexx : une boîte à outils Python pur pour créer des applications GUI. Il utilise la technologie Web pour le rendu de l'interface. Vous pouvez utiliser Flexx pour créer des applications de bureau et vous pouvez également exporter une application vers un document HTML autonome. Parce qu'il est développé en Python pur, Flexx est multiplateforme. Tout ce dont vous avez besoin est Python et un navigateur pour fonctionner.
• pywebview est un wrapper multiplateforme léger autour du composant webview qui permet d'afficher du contenu HTML dans sa propre fenêtre d'interface graphique native. Il vous permet d'utiliser les technologies Web dans vos applications de bureau tout en cachant autant que possible le fait que vous utilisez un navigateur pour construire votre interface graphique.
• enaml : un framework Python qui vous permet d'obtenir des interfaces graphiques de haute qualité avec un minimum d'effort et un langage de programmation unique. enaml combine un langage déclaratif avec un système de mise en page basé sur des contraintes, permettant aux utilisateurs de définir facilement des interfaces utilisateur à mise en page flexible. Les applications enaml peuvent s'exécuter sur n'importe quelle plate-forme prenant en charge Python et Qt.

Réflexions personnelles : Trop de choses à apprendre, apprenez d'abord PyQt5, la raison en est qu'il y a beaucoup d'informations, puis apprenez pyside6 si vous avez assez d'énergie pour apprendre, et enfin regardez PySimpleGUI pour voir si vous pouvez résoudre quelques problèmes simples.

Présentation de PyQt5

PyQt est l'implémentation en langage Python du framework Qt, développé par Riverbank Computing, et est l'une des bibliothèques GUI les plus puissantes. PyQt fournit une collection bien conçue de contrôles de fenêtre, et chaque contrôle PyQt correspond à un contrôle Qt, donc l'interface API de PyQt est très proche de celle de Qt, mais PyQt n'utilise plus le système QMake et la macro Q_OBJECT.

PyQt5 fournit des certificats de version GPL et de version commerciale. Les développeurs gratuits peuvent utiliser la licence GPL gratuite. Si vous avez besoin d'utiliser PyQt pour des applications commerciales, vous devez acheter une licence commerciale.

Les fonctionnalités de PyQt5 sont les suivantes :

• Un jeu de contrôle d'interface graphique basé sur Qt hautes performances.
• Il peut fonctionner sur les systèmes Linux, Windows et Mac OS sur toutes les plates-formes.
• Utilisez le mécanisme de signal-slot pour la communication.
• Encapsulez entièrement la bibliothèque Qt.
• Vous pouvez utiliser un IDE mature pour la conception d'interface et générer automatiquement du code Python exécutable.
• Fournit un ensemble complet de contrôles de fenêtre de toutes sortes.
• PyQt5 est composé d'une série de modules Python, avec plus de 620 classes, 6000 fonctions et méthodes, les principaux modules sont les suivants :
• QtCore : Contient des fonctions principales non graphiques. Fonctionne principalement avec le temps, les fichiers et les dossiers, diverses données, les flux, les URL, les fichiers de type mime, les processus et les threads.
• QtGui : contient le système de fenêtres, la gestion des événements, les images 2D, la peinture de base, les polices et les classes de texte.
• QtWidgets : contient une série d'éléments d'interface utilisateur pour créer des applications de bureau.
• QtMultimedia : Contient des classes qui gèrent le contenu multimédia et appellent l'API de la caméra.
• QtBluetooth : contient des classes pour rechercher et se connecter à Bluetooth.
• QtNetwork : Contient des classes pour la programmation réseau, ces outils rendent le développement TCP/IP et UDP plus pratique et fiable.
• QtPositioning : Contient des classes pour le positionnement, l'utilisation du satellite, du Wi-Fi et même du texte.
• Enginio : Contient des classes pour entrer et gérer Qt Cloud via le client.
• QtWebSockets : contient des classes pour le protocole WebSocket.
• QtWebKit : contient un navigateur Web basé sur WebKit2.
• QtWebKitWidgets : Contient les classes de WebKit1 basées sur QtWidgets.
• QtXml : Contient des classes pour le traitement du xml et fournit des outils pour les API SAX et DOM.
• QtSvg : Fournit une classe pour afficher du contenu SVG. Scalable Vector Graphics (SVG) est un format graphique basé sur Extensible Markup Language (XML) pour décrire des graphiques vectoriels en deux dimensions (cette phrase provient de Wikipedia).
• QtSql : fournit des outils pour travailler avec des bases de données.
• QtTest : Fournit des outils pour tester les applications PyQt5.

Installation de PyQt5

Étant donné que fbs sera utilisé pour l'empaquetage à un stade ultérieur, fbs peut avoir des problèmes de compatibilité avec les versions ultérieures à Python 3.7, j'ai donc choisi Python 3.6.8 pour créer l'environnement complet. Le contenu principal est : Python + PyCharm + PyQt5

Installer PyQt5

pip install pyqt5

pip install pyqt5-tools

Parmi eux, pyqt5-tools est un outil de conception d'interface par glisser-déposer pour Qt Designer. L'erreur suivante peut être signalée pendant le processus d'installation :

qt5-tools 5.15.2.1.2 has requirement click~=7.0, but you'll have click 8.0.1 which is incompatible.

solution:

pip install click~=7.0

Configuration de Qt Designer

Qt Designer consiste à placer des contrôles par glisser-déposer et à afficher les effets des contrôles en temps réel pour une conception rapide de l'interface utilisateur.

La composition de tout l'écran :

• La "Widget Box" sur la gauche est une variété de composants qui peuvent être déplacés librement
• Le formulaire du milieu "MainWindow - sans titre" est le canevas
• "L'inspecteur d'objets" en haut à droite peut voir la structure de l'interface utilisateur actuelle
• "L'éditeur de propriétés" au milieu de la droite peut définir les propriétés du composant actuellement sélectionné
• Le "Navigateur de ressources" en bas à droite peut ajouter divers matériaux, tels que des images, des arrière-plans, etc.

Enfin, un fichier .ui (essentiellement un fichier au format XML) est généré, qui peut être utilisé directement ou converti en fichier .py par l'outil pyuic5.

Configuration de QtDesigner

Dans Pycharm, ouvrez à tour de rôle Fichier – Paramètres – Outils – Outils externes, cliquez sur + Créer un outil, et configurez comme suit :

Name: QtDisigner

Program : D:\Program Files\Python36\Lib\site-packages\qt5_applications\Qt\bin\designer.exe # 请根据实际修改

Working directory: $FileDir$

Configuration PyUIC

PyUIC remplace principalement les fichiers .ui générés par Qt Designer par des fichiers .py.

Dans Pycharm, ouvrez à tour de rôle Fichier – Paramètres – Outils – Outils externes, cliquez sur + Créer un outil, et configurez comme suit :

Name: PyUIC

Program : D:\Program Files\Python36\python.exe # 当前Python目录，请根据实际修改

Arguments: -m PyQt5.uic.pyuic $FileName$ -o $FileNameWithoutExtension$.py

Working directory: $FileDir$

Configuration PyrRCC

PyRCC remplace principalement le fichier de ressources écrit .qrc par un fichier .py. Dans Pycharm, ouvrez à tour de rôle Fichier – Paramètres – Outils – Outils externes, cliquez sur + Créer un outil, et configurez comme suit :

Name: PyRCC

Program: D:\Program Files\Python36\pyrcc5.exe # 当前rcc工具目录，请根据实际修改

Arguments: $FileName$ -o $FileNameWithoutExtension$_rc.py

Working directory: $FileDir$

Exemple d'utilisation de PyQt5

Créez une interface vierge :

import sys

from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel

app = QApplication(sys.argv)

win = QMainWindow()

win.setGeometry(400, 400, 400, 300)

win.setWindowTitle("Pyqt5 Tutorial")

win.show()

sys.exit(app.exec_())

dans:

• Qapplication() : chaque interface graphique doit contenir une Qapplication, et argv signifie obtenir les paramètres de la ligne de commande. Si vous n'en avez pas besoin, vous pouvez utiliser [] à la place.
• QMainWindow() : Semblable à un conteneur (fenêtre) utilisé pour contenir des widgets tels que des boutons, du texte et des zones de saisie. Le drapeau arg peut obtenir les paramètres lorsque la ligne de commande est exécutée.
• SetGeometry est utilisé pour définir la taille de la fenêtre QMainWindow(), syntaxe : setGeometry(x, y, largeur, hauteur), où x, y sont des points de coordonnées sur l'écran.
• show() : utilisé pour afficher la fenêtre
• exit(app.exec_()) : définissez la fenêtre pour qu'elle s'exécute tout le temps et vous guide pour utiliser le bouton de fermeture pour fermer

Les widgets communs pris en charge par PyQt5 sont :

De haut en bas, de gauche à droite : Qlabel, QcomboBox, QcheckBox, QradioButton, QpushButton, QtableWidget, QlineEdit, Qslider, QProgressBar

Pour définir le contenu du texte avec Pyqt5, nous utilisons Qlabel :

import sys

from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel

app = QApplication(sys.argv)

win = QMainWindow()

win.setGeometry(400, 400, 400, 300)

win.setWindowTitle("Pyqt5 Tutorial")

# Label Text

label = QLabel(win)

label.resize(200, 100)

label.setText("Hi this is Pyqt5")

label.move(100, 100)

win.show()

sys.exit(app.exec_())

Boutons et événements :

import sys

from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton

def click():

    print("Hy Button is clicked!")

app = QApplication(sys.argv)

win = QMainWindow()

win.setGeometry(400, 400, 400, 300)

win.setWindowTitle("Pyqt5 Tutorial")

# Button

button = QPushButton(win)

button.resize(200, 100)

button.setText("Hi! Click Me")

button.move(100, 100)

button.clicked.connect(click)

win.show()

sys.exit(app.exec_())

button.clicked.connect() exécute un événement spécifique après avoir cliqué sur le bouton.

Combat PyQt5

Projet pratique : logiciel de requête météorologique simple

1. Utiliser Qt Designer pour concevoir une interface

Les contrôles utilisés sont Button, GroupBox, Label, ComboBox et TextEdit, et deux boutons queryBtn et clearBtn sont définis en même temps, qui sont utilisés pour interroger et effacer les données météorologiques respectivement. Nous devons lier la fonction slot comme suit :

• Sélectionnez l'éditeur de signal/slot dans le coin inférieur droit de Qt Designer, cliquez sur le signe + pour ajouter
• Sélectionnez queryBtn et clearBtn respectivement, sélectionnez signal clicked(), receiver Dialog et slot accept(), (je ne sais pas comment définir la fonction slot ici et la modifier plus tard dans le code)

Une fois ce qui précède terminé, enregistrez-le en tant que fichier Weather.ui.

2. Convertir le fichier .ui en fichier .py

PyQt5 prend en charge l'utilisation directe des fichiers .ui :

import sys

from PyQt5 import QtWidgets, uic

app = QtWidgets.QApplication(sys.argv)

window = uic.loadUi("mainwindow.ui")

window.show()

app.exec()

Mais afin de mieux personnaliser et modifier la fonction d'emplacement ci-dessus, vous pouvez utiliser Outils externes - PyUIC pour générer Weather.py, la commande en cours d'exécution est la suivante :

D:\Program Files\Python36\python.exe -m PyQt5.uic.pyuic Weather.ui -o Weather.py

Parmi eux, nous devons lier la fonction slot des deux boutons :

# self.queryBtn.clicked.connect(Dialog.accept)

# self.clearBtn.clicked.connect(Dialog.accept)

# 修改为：

self.queryBtn.clicked.connect(Dialog.queryWeather)

self.clearBtn.clicked.connect(Dialog.clearText)

Le contenu final de Weather.py est le suivant :

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'Weather.ui'

#

# Created by: PyQt5 UI code generator 5.15.4

#

# WARNING: Any manual changes made to this file will be lost when pyuic5 is

# run again.  Do not edit this file unless you know what you are doing.

from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_Dialog(object):

    def setupUi(self, Dialog):

        Dialog.setObjectName("Dialog")

        Dialog.resize(600, 600)

        self.groupBox = QtWidgets.QGroupBox(Dialog)

        self.groupBox.setGeometry(QtCore.QRect(30, 20, 551, 511))

        self.groupBox.setObjectName("groupBox")

        self.label_2 = QtWidgets.QLabel(self.groupBox)

        self.label_2.setGeometry(QtCore.QRect(20, 30, 31, 16))

        self.label_2.setObjectName("label_2")

        self.comboBox = QtWidgets.QComboBox(self.groupBox)

        self.comboBox.setGeometry(QtCore.QRect(70, 30, 87, 22))

        self.comboBox.setObjectName("comboBox")

        self.comboBox.addItem("")

        self.comboBox.addItem("")

        self.comboBox.addItem("")

        self.textEdit = QtWidgets.QTextEdit(self.groupBox)

        self.textEdit.setGeometry(QtCore.QRect(20, 70, 491, 411))

        self.textEdit.setObjectName("textEdit")

        self.queryBtn = QtWidgets.QPushButton(Dialog)

        self.queryBtn.setGeometry(QtCore.QRect(490, 560, 93, 28))

        self.queryBtn.setObjectName("queryBtn")

        self.clearBtn = QtWidgets.QPushButton(Dialog)

        self.clearBtn.setGeometry(QtCore.QRect(30, 560, 93, 28))

        self.clearBtn.setObjectName("clearBtn")

        self.retranslateUi(Dialog)

        self.clearBtn.clicked.connect(Dialog.clearText)

        self.queryBtn.clicked.connect(Dialog.queryWeather)

        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):

        _translate = QtCore.QCoreApplication.translate

        Dialog.setWindowTitle(_translate("Dialog", "Dialog"))

        self.groupBox.setTitle(_translate("Dialog", "城市天气预报"))

        self.label_2.setText(_translate("Dialog", "城市"))

        self.comboBox.setItemText(0, _translate("Dialog", "北京"))

        self.comboBox.setItemText(1, _translate("Dialog", "苏州"))

        self.comboBox.setItemText(2, _translate("Dialog", "上海"))

        self.queryBtn.setText(_translate("Dialog", "查询"))

        self.clearBtn.setText(_translate("Dialog", "清空"))

3. Appelez MainDialog

Appelez la classe d'interface Ui_Dialog dans MainDialog, puis ajoutez le code de logique métier pour interroger la météo, afin que l'affichage de l'interface et la logique métier soient séparés. Ajoutez un nouveau fichier demo.py et définissez deux fonctions d'emplacement queryWeather() et clearText() dans la classe MainDialog, afin que les deux boutons (queryBtn et clearBtn) définis dans le fichier d'interface Weather.ui puissent déclencher le signal cliqué et ces deux fonctions Slot sont liées.

Le code complet est le suivant :

import sys

import Weather

from PyQt5.QtWidgets import QApplication, QDialog

import requests

class MainDialog(QDialog):

    def __init__(self, parent=None):

        super(QDialog, self).__init__(parent)

        self.ui = Weather.Ui_Dialog()

        self.ui.setupUi(self)

    def queryWeather(self):

        cityName = self.ui.comboBox.currentText()

        cityCode = self.getCode(cityName)

        r = requests.get(

            "https://restapi.amap.com/v3/weather/weatherInfo?key=f4fd5b287b6d7d51a3c60fee24e42002&city={}".format(

                cityCode))

        if r.status_code == 200:

            data = r.json()['lives'][0]

            weatherMsg = '城市：{}\n天气：{}\n温度：{}\n风向：{}\n风力：{}\n湿度：{}\n发布时间：{}\n'.format(

                data['city'],

                data['weather'],

                data['temperature'],

                data['winddirection'],

                data['windpower'],

                data['humidity'],

                data['reporttime'],

            )

        else:

            weatherMsg = '天气查询失败，请稍后再试！'

        self.ui.textEdit.setText(weatherMsg)

    def getCode(self, cityName):

        cityDict = {"北京": "110000",

                    "苏州": "320500",

                    "上海": "310000"}

        **return** cityDict.get(cityName, '101010100')

    def clearText(self):

        self.ui.textEdit.clear()

if __name__ == '__main__':

    myapp = QApplication(sys.argv)

    myDlg = MainDialog()

    myDlg.show()

    sys.exit(myapp.exec_())

L'effet après avoir exécuté demo.py et exécuté la requête :

4. Empaqueter le code dans un fichier exe

L'empaquetage de fichiers .py dans un exe exécutable s'appelle le gel en Python. Les outils couramment utilisés incluent : PyInstaller, py2exe, cx_Freeze, bbfreze, py2app, etc. Comparaison des fonctions :

• py2exe : la mise à jour du logiciel n'est plus active, elle est donc ignorée.
• pyinstaller : prend clairement en charge win8, win10, prend théoriquement en charge win7, prend en charge Apple Macos, linux. pyinsaller peut être conditionné sous la forme d'un dossier contenant le fichier d'exécution d'entrée exe, ou il peut s'agir d'un fichier exe séparé.
• fbs : basé sur PyInstaller, il est plus pratique à utiliser

Ici, fbs est sélectionné pour l'emballage. Comment installer fbs :

pip install fbs

Pour l'utiliser, entrez sur la ligne de commande :

fbs startproject

Une fois l'exécution terminée, vous devez entrer le nom de certaines applications, etc. Une fois terminé, le répertoire suivant sera généré :

Faites glisser le code PyQt5 (demo.py et Weather.py) que vous venez d'écrire dans le dossier src/main/python, supprimez le main.py d'origine et modifiez demo.py en main.py. Ouvrez ensuite main.py et ajoutez le code suivant en haut du fichier :

from fbs_runtime.application_context.PyQt5 import ApplicationContext
```
完成后执行：
```
fbs freeze
```
即可实现打包。生成的exe可执行文件在\target\MyApp文件下。

Digression

Au cours de cette première année de technologie à croissance rapide, la programmation est comme un billet vers un monde de possibilités infinies pour de nombreuses personnes. Dans la lignée des langages de programmation vedettes, Python est comme la superstar leader. Avec sa syntaxe concise et facile à comprendre et ses fonctions puissantes, il se démarque et devient l'un des langages de programmation les plus populaires au monde.

L'essor rapide de Python est extrêmement bénéfique pour l'ensemble de l'industrie , mais " 人红是非多" lui a fait ajouter de nombreuses critiques, mais il ne peut toujours pas arrêter son élan de développement.

Python restera-t-il pertinent et intact pour le reste de la prochaine décennie ? Aujourd'hui, nous allons analyser les faits et dissiper certaines idées fausses.

Si vous êtes intéressé par Python et souhaitez obtenir un salaire plus élevé en apprenant Python, alors l'ensemble de matériel d'apprentissage Python suivant doit vous être utile !

Les matériaux incluent : package d'installation Python + code d'activation, développement Web Python, robot d'exploration Python, analyse de données Python, intelligence artificielle, apprentissage automatique et autres didacticiels d'apprentissage. Même les débutants avec 0 bases peuvent comprendre et comprendre. Suivez le tutoriel et amenez-vous à apprendre Python systématiquement à partir de zéro bases !
​

1. Apprendre les routes dans toutes les directions de Python

L'itinéraire de toutes les directions en Python consiste à organiser les points techniques couramment utilisés de Python pour former un résumé des points de connaissance dans divers domaines. Son utilité réside dans le fait que vous pouvez trouver des ressources d'apprentissage correspondantes en fonction des points de connaissance ci-dessus pour vous assurer que vous apprenez plus exhaustivement.

2. Logiciel d'apprentissage Python

Si un ouvrier veut faire du bon travail, il doit d'abord affûter ses outils. Le logiciel de développement couramment utilisé pour apprendre Python est arrivé !

3. Vidéo d'apprentissage d'introduction à Python

Il existe également de nombreuses vidéos d'apprentissage adaptées pour démarrer avec les bases de 0. Avec ces vidéos, vous pouvez facilement démarrer avec Python~

4. Exercices Python

Après chaque leçon vidéo, il y a des questions pratiques correspondantes, vous pouvez tester les résultats d'apprentissage haha !

Cinq, cas de combat réel Python

La théorie optique est inutile. Vous devez apprendre à taper des codes avec elle, puis vous pouvez appliquer ce que vous avez appris dans la pratique. À ce stade, vous pouvez apprendre de quelques cas pratiques. Cette information est également incluse~

6. Matériel d'entretien Python

Après avoir appris Python, nous pouvons sortir et trouver un emploi avec les compétences ! Les questions d'entretien suivantes proviennent toutes de grandes sociétés Internet telles qu'Ali, Tencent, Byte, etc., et certains patrons d'Ali ont donné des réponses faisant autorité. Après avoir lu cet ensemble de documents d'entretien, je pense que tout le monde peut trouver un emploi satisfaisant.


7. Collecte d'informations

L'ensemble complet de supports d'apprentissage pour la version complète de Python mentionnée ci-dessus a été téléchargé sur le site officiel CSDN.Ceux qui en ont besoin peuvent scanner le code QR de la certification officielle CSDN ci-dessous sur WeChat pour le recevoir gratuitement.
​