Connaissances de base sur Python
Annexe 1 du tutoriel vidéo - syntaxe python : https://singtown.com/learn/50061/
Avantages de l'utilisation de python
OpenMV peut utiliser Python pour le développement secondaire. Il y a plusieurs avantages :
- Facile à prendre en main
- Pas besoin de se soucier de l'allocation et de la libération de la mémoire
- De nombreuses bibliothèques MicroPython peuvent être utilisées directement (non compatibles avec les modules Python sur PC)
- L'équipe de développement a développé divers algorithmes et modules qu'OpenMV peut appeler
Python est un langage très couramment utilisé, largement utilisé dans le traitement d'image, l'apprentissage automatique, et la programmation réseau. Et Python est un langage très facile à utiliser. Si vous avez de l'expérience en programmation dans d'autres langages (comme C, C++, Java), il vous sera plus facile de démarrer.
Si vous avez déjà de l'expérience en programmation en C/C++/Java (ou tout autre langage), je recommande \ le tutoriel Python de Liao Xuefeng
Si vous n'avez aucune expérience de programmation préalable, il est recommandé de suivre\ Learn Python the hard way
REPL et port série
L'IDE d'OpenMV est fourni avec un assistant de port série pour se connecter à OpenMV, et peut également se connecter à d'autres ports série, comme Arduino, pyboard, esp8266.
Tout d'abord, déconnectez OpenMV de l'IDE, sinon le port série entrera en conflit !
Ouvrez Outils → Ouvrir le terminal → Nouveau terminal dans OpenMV
Tapez dans le terminal
print("hello OpenMV!")
Cela affichera
hello OpenMV!
Syntaxe Python
Sortie
Utilisez print() pour ajouter une chaîne de caractères entre parenthèses afin d'afficher le texte spécifié à l'écran. Par exemple, pour afficher 'hello, world', le code est le suivant :
print('hello, world')
hello, world
La fonction print() peut également accepter plusieurs chaînes de caractères, séparées par des virgules ",", qui seront ensuite assemblées pour l'affichage :
print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dog
print() affichera chaque chaîne de caractères l'une après l'autre, et un espace sera inséré à chaque virgule ",", donc la chaîne de sortie est assemblée ainsi :
The quick brown fox jumps over the lazy dog
print() peut aussi afficher des entiers ou des résultats de calcul :
print(300)
300
print(100 + 200)
300
Nous pouvons donc afficher le résultat du calcul 100 + 200 de manière plus élégante :
print('100 + 200 =', 100 + 200)
100 + 200 = 300
Notez que pour 100 + 200, l'interpréteur Python calcule automatiquement le résultat 300, mais '100 + 200 =' est une chaîne de caractères et non une formule mathématique, et Python la traite comme une chaîne de caractères.
Variables
En Python, le signe égal = est une instruction d'affectation, qui peut affecter n'importe quel type de données à une variable. La même variable peut être réaffectée plusieurs fois, et peut recevoir des variables de types différents, par exemple :
a = 123 # a est un entier
print(a)
a = 'ABC' # a devient une chaîne de caractères
print(a)
Ce langage dans lequel le type de la variable elle-même n'est pas fixe est appelé un langage dynamique, par opposition à un langage statique. Les langages statiques doivent spécifier le type de la variable lors de sa définition. Si le type ne correspond pas lors de l'affectation, une erreur sera signalée. Par exemple, Java est un langage statique, et l'instruction d'affectation est la suivante (// indique un commentaire) :
int a = 123; // a est une variable de type entier
a = "ABC"; // Erreur : impossible d'affecter une chaîne de caractères à une variable entière
Comparés aux langages statiques, les langages dynamiques sont plus flexibles, c'est pourquoi.
Liste
L'un des types de données intégrés de Python est la liste : list. Une liste est une collection ordonnée dans laquelle des éléments peuvent être ajoutés et supprimés à tout moment.\ Par exemple, pour lister les noms de tous les camarades de classe, vous pouvez utiliser une liste pour la représenter :
classmates = ['Michael', 'Bob', 'Tracy']
classmates
['Michael', 'Bob', 'Tracy']
La variable classmates est une liste. Utilisez la fonction len() pour obtenir le nombre d'éléments de la liste :
len(classmates)
3
Utilisez l'index pour accéder à l'élément à chaque position de la liste. Rappelez-vous que l'index commence à 0 :
classmates[0]
'Michael'
classmates[1]
'Bob'
classmates[2]
'Tracy'
classmates[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Lorsque l'index est hors limites, Python signalera une erreur IndexError, assurez-vous donc que l'index ne dépasse pas la limite. Rappelez-vous que l'index du dernier élément est len(classmates) - 1.
Si vous voulez obtenir le dernier élément, en plus de calculer la position de l'index, vous pouvez également utiliser -1 comme index pour obtenir directement le dernier élément :
classmates[-1]
'Tracy'
Par analogie, vous pouvez obtenir l'avant-dernier et l'antépénultième :
classmates[-2]
'Bob'
classmates[-3]
'Michael'
classmates[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Bien sûr, le quatrième en partant de la fin est hors limites.
Une liste est une liste ordonnée mutable, vous pouvez donc ajouter des éléments à la fin de la liste :
classmates.append('Adam')
classmates
['Michael', 'Bob', 'Tracy', 'Adam']
Vous pouvez également insérer des éléments à une position spécifiée, comme l'index 1 :
classmates.insert(1, 'Jack')
classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
Pour supprimer un élément à la fin d'une liste, utilisez la méthode pop() :
classmates.pop()
'Adam'
classmates
['Michael', 'Jack', 'Bob', 'Tracy']
Pour remplacer un élément par un autre, vous pouvez directement affecter la valeur à la position d'index correspondante :
classmates[1] = 'Sarah'
classmates
['Michael', 'Sarah', 'Tracy']
Les types de données des éléments d'une liste peuvent également être différents, par exemple :
L = ['Apple', 123, True]
Si une liste n'a pas d'éléments, c'est une liste vide de longueur 0 :
L = []
len(L)
0
Tuple
Une autre liste ordonnée est appelée tuple. Les tuples ressemblent beaucoup aux listes, mais une fois qu'un tuple est initialisé, il ne peut pas être modifié. Par exemple, il liste également les noms des camarades de classe :
classmates = ('Michael', 'Bob', 'Tracy')
Maintenant, le tuple classmates ne peut pas être modifié, et il n'a pas de méthodes telles que append() et insert(). Les autres méthodes pour obtenir les éléments sont les mêmes que pour les listes. Vous pouvez utiliser classmates[0] et classmates[-1] normalement, mais vous ne pouvez pas les réaffecter à d'autres éléments.
Quelle est l'utilité des tuples immuables ? Parce que les tuples sont immuables, le code est plus sûr. Si possible, utilisez des tuples plutôt que des listes.
Piège du tuple : lorsque vous définissez un tuple, les éléments du tuple doivent être déterminés au moment de la définition, par exemple :
t = (1, 2)
t
(1, 2)
Cependant, pour définir un tuple avec un seul élément, si vous le définissez ainsi :
t = (1)
t
1
Cette définition n'est pas un tuple, t est une variable entière, et la valeur de la variable t est 1 ! C'est parce que les parenthèses () peuvent représenter à la fois des tuples et des parenthèses dans des formules mathématiques, ce qui crée une ambiguïté. Par conséquent, Python stipule que dans ce cas, le calcul est effectué selon les parenthèses mathématiques, et le résultat du calcul est naturellement 1.
Par conséquent, une virgule , doit être ajoutée lors de la définition d'un tuple avec un seul élément pour éliminer l'ambiguïté :
t = (1,)
t
(1,)
Python ajoute également une virgule , lors de l'affichage d'un tuple avec un seul élément, afin que vous ne le confondiez pas avec une parenthèse au sens d'un calcul mathématique.
Instruction conditionnelle
La forme complète de l'instruction if est :
if <condition1>:
<exécution1>
elif <condition2>:
<exécution2>
elif <condition3>:
<exécution3>
else:
<exécution4>
Par exemple :
age = 20
if age >= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')
Boucle
Python dispose de deux types de boucles. La première est la boucle for...in, qui itère sur chaque élément de la liste ou du tuple l'un après l'autre. Voir l'exemple :
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
L'exécution de ce code affichera chaque élément de names l'un après l'autre :
Michael
Bob
Tracy
Ainsi, la boucle for x in ... substitue chaque élément à la variable x, puis exécute les instructions dans le bloc indenté.
Si vous voulez calculer la somme des entiers de 1 à 100, il est un peu fastidieux de les écrire de 1 à 100. Heureusement, Python fournit une fonction range() qui peut générer une séquence d'entiers, qui peut être convertie en liste grâce à la fonction list(). Par exemple, range(5) génère une séquence d'entiers inférieurs à 5 à partir de 0 :
list(range(5))
[0, 1, 2, 3, 4]
range(101) peut générer une séquence d'entiers de 0 à 100, et le calcul est le suivant :
sum = 0
for x in range(101):
sum = sum + x
print(sum)
La seconde boucle est la boucle while. Par exemple, si nous voulons calculer la somme de tous les nombres impairs jusqu'à 100, nous pouvons utiliser une boucle while pour la réaliser :
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
===== Conversion de type de données =====
Les fonctions courantes intégrées de Python incluent également des fonctions de conversion de type de données, comme la fonction int(), qui peut convertir d'autres types de données en entiers :
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False
===== Fonction =====
En Python, pour définir une fonction, vous devez utiliser l'instruction def, écrire dans l'ordre le nom de la fonction, les parenthèses, les paramètres dans les parenthèses, et les deux-points :, puis écrire le corps de la fonction dans le bloc indenté, et renvoyer le résultat avec l'instruction return.
Écrivons d'abord une fonction pour calculer x2 :
def power(x):
return x * x
Pour la fonction power(x), le paramètre x est un paramètre positionnel.
Lorsque nous appelons la fonction power, nous devons passer un et un seul paramètre x :
power(5)\ 25\ power(15)\ 225
Maintenant, que faire si nous voulons calculer x3 ? Nous pouvons définir une autre fonction power3, mais que faire si nous voulons calculer x4, x5, etc. ? Nous ne pouvons pas définir un nombre infini de fonctions.
Vous avez peut-être pensé que nous pouvons modifier power(x) en power(x, n) pour calculer xn, et le faire tout de suite :
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
Pour cette fonction power(x, n) modifiée, nous pouvons calculer n'importe quelle puissance de n :
power(5, 2)\ 25\ power(5, 3)\ 125
La fonction power(x, n) modifiée a deux paramètres : x et n. Les deux paramètres sont des paramètres positionnels. Lors de l'appel de la fonction, les deux valeurs passées sont affectées aux paramètres x et n selon leur ordre de position.
Découpage (slicing)
Prendre une partie d'une liste ou d'un tuple est une opération très courante. Par exemple, une liste est la suivante :
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
Prenez les 3 premiers éléments et découpez-les avec une ligne de code :
L[0:3]\ ['Michael', 'Sarah', 'Tracy']
L[0:3] signifie commencer à l'index 0 et se terminer à l'index 3, sans inclure l'index 3. C'est-à-dire que les index 0, 1, et 2 sont exactement 3 éléments.
Si le premier index est 0, il peut être omis :
L[:3]\ ['Michael', 'Sarah', 'Tracy']
Vous pouvez également commencer à l'index 1 et extraire 2 éléments :
L[1:3]\ ['Sarah', 'Tracy']
Le tuple est également une sorte de liste, la seule différence étant que le tuple est immuable. Par conséquent, les tuples peuvent également être découpés, mais le résultat de l'opération reste un tuple :
(0, 1, 2, 3, 4, 5)[:3]\ (0, 1, 2)
La chaîne de caractères 'xxx' peut également être considérée comme une liste, où chaque élément est un caractère. Par conséquent, les chaînes de caractères peuvent également être découpées, mais le résultat de l'opération reste une chaîne de caractères :
'ABCDEFG'[:3]\ 'ABC'
Objet
Python est un langage de programmation orientée objet, comme par exemple une LED
from pyb import LED
red_led = LED(1)
red_led.on()
LED est une classe, red_led est un objet, et cet objet peut être manipulé, par exemple pour l'allumer, l'éteindre, et vérifier sa valeur.