Guide de base sur l'utilisation des opérateurs et instructions Python (conditions, boucles, exceptions)

Classification des opérateurs

opérateurs arithmétiques
opérateur d'assignation
opérateur d'affectation composé
opérateur de comparaison
Opérateurs logiques

opérateurs arithmétiques

opérateur	décrire	Exemple
+	ajouter	1 + 1 sorties 2
-	réduire	1 - 1 résultat de sortie est 0
*	prendre	2*2 sorties 4
/	retirer	10 / 2 La sortie est 5
//	Divisible	9 // 4 la sortie est 2
%	Prenez le reste	9 % 4 la sortie est 1
**	indice	2 ** 4 Le résultat de sortie est 16,`2 * 2 * 2 * 2`
()	Parenthèses	Les parenthèses sont utilisées pour augmenter la priorité de l'opération, c'est-à-dire (1 + 2) * 3, le résultat de sortie est 9

Note:

Ordre de priorité des opérations mixtes : () supérieur à ** supérieur à * / // % supérieur à + -
Puisque l'opérateur arithmétique est un opérateur binaire, c'est-à-dire qu'il y a deux opérandes participant à l'opération. Lorsque les types des deux opérandes participant à l'opération sont incohérents, convertissez-les d'abord en le même type, puis effectuez l'opération. Sinon, une erreur sera demandée.

Les règles de base pour la conversion sont :
- Si l'un des deux opérandes participant à une opération arithmétique est un nombre complexe, l'autre est également converti en nombre complexe ;
- Si l'un des deux opérandes est un nombre à virgule flottante, remplacez l'autre par un nombre à virgule flottante ;
- Si l’un des deux opérandes est un entier long, l’autre est également converti en entier long.
Lors de la conversion, la conversion entre différents types doit respecter un certain sens de conversion. Par exemple, un nombre à virgule flottante ne peut pas être converti en un entier et un nombre complexe ne peut pas être converti en d'autres types numériques.

opérateur d'assignation

Affectation d'une seule variable (affectation simple)
```
num = 1
print ( num )
```
Affectation de plusieurs variables (affectation de séquence)

Dans une instruction d'affectation de séquence, le côté gauche du signe égal est constitué de plusieurs variables représentées par des tuples ou des listes, et le côté droit du signe égal est constitué de données représentées par des séquences telles que des tuples, des listes ou des chaînes. Python attribue des données aux variables dans l'ordre.
```
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)
```
Note:
- Lorsque le côté droit du signe égal est une chaîne,Python décomposera la chaîne en caractères individuels et les affectera tour à tour à chaque variable.À ce stade, le nombre de variables et le nombre de caractères doivent être égaux, sinon une erreur se produira. se produire;
```
a, b, c, d, f = 'hello'
print(a)
print(b)
print(c)
print(d)
print(f)
```
- Lors de l'attribution de valeurs dans une séquence, vous pouvez utiliser * avant le nom de la variable. Les variables sans astérisques ne correspondent qu'à une seule valeur et les valeurs restantes sont attribuées aux variables avec des astérisques sous forme de liste.
```
a, b, *c = 'hello'
print(a)
print(b)
print(c)
```
Attribuer la même valeur à plusieurs variables (affectation multi-cibles)
```
a = b = 10
print(a)
print(b)
```

opérateur d'affectation composé

opérateur	décrire	Exemple
+=	opérateur d'affectation d'addition	c += a est équivalent à c == c + a
-=	opérateur d'affectation de soustraction	c -= a est équivalent à c == c - a
*=	opérateur d'affectation de multiplication	c = a est équivalent à c == c a
/=	opérateur d'affectation de division	c /= a est équivalent à c == c / a
//=	Opérateur d'affectation de division entière	c //= a est équivalent à c == c // a
%=	opérateur d'affectation du reste	c % = a est équivalent à c == c % a
**=	Opérateur d'affectation de puissance	`c = a`Équivalent à`c = c a`

opérateur de comparaison

opérateur	décrire
==	Jugé égal. Si les résultats des deux opérandes sont égaux, le résultat de la condition est True (True), sinon il est False (False)
!=	pas égal à. Si les résultats des deux opérandes ne sont pas égaux, le résultat de la condition est vrai (True), sinon il est faux (False)
>	Si le résultat de l'opérande du côté gauche de l'opérateur est supérieur au résultat de l'opérande du côté droit de l'opérateur. S'il est supérieur, la condition est vraie, sinon elle est fausse.
<	Si le résultat de l'opérande du côté gauche de l'opérateur est inférieur au résultat de l'opérande du côté droit de l'opérateur. S'il est inférieur, la condition est vraie, sinon elle est fausse.
`>=`	Si le résultat de l'opérande du côté gauche de l'opérateur est supérieur ou égal au résultat de l'opérande du côté droit de l'opérateur. S'il est supérieur ou égal au résultat, la condition est vraie, sinon elle c'est faux.
<=	Si le résultat de l'opérande du côté gauche de l'opérateur est inférieur ou égal au résultat de l'opérande du côté droit de l'opérateur. S'il est inférieur ou égal au résultat, la condition est vraie, sinon elle c'est faux.

Opérateurs logiques

opérateur	expression logique	décrire	Exemple
et	x et y	ET booléen : si x et y sont tous deux vrais, alors x et y sont vrais, sinon ils sont faux	Vrai et Faux, renvoie Faux
ou	x ou y	"ou" booléen : si x et y sont tous deux faux, alors x et y sont faux, sinon vrai	Vrai ou Faux, renvoie Vrai
pas	pas x	Booléen « non » : si x est vrai, renvoie False. Si x est faux, renvoie vrai	pas vrai, renvoie faux

opérateur ternaire

En Python, l'opérateur ternaire (également appelé opérateur conditionnel) est une manière concise d'écrire des expressions conditionnelles.

La structure syntaxique est la suivante :

value_if_true if condition else value_if_false

# 示例
x = 10
y = 20
max_value = x if x > y else y		# 输出：20

Instruction conditionnelle (if-elif-else)

si déclaration

if 条件:
  条件成⽴执⾏的代码1
  条件成⽴执⾏的代码2
  ......

sinon…

if 条件:
  条件成⽴执⾏的代码
  ......
else:
  条件不成⽴执⾏的代码
  ......

plusieurs jugements

if 条件1:
  条件1成⽴执⾏的代码
  ......
elif 条件2：
  条件2成⽴执⾏的代码
  ......
......
else:
  以上条件都不成⽴执⾏执⾏的代码

si imbriqué

if 条件1：
  条件1成⽴执⾏的代码
  ......
  if 条件2：
    条件2成⽴执⾏的代码
    ......

Instructions de boucle (for, while)

pour la boucle

La boucle for est l'une des instructions de boucle les plus couramment utilisées en Python et peut parcourir n'importe quelle séquence, telle qu'une liste ou une chaîne.

La syntaxe de base est la suivante :

for variable in sequence:
    # 循环体
[else]
	# 循环体

variable : représente le nom de la variable
séquence : représente la séquence à parcourir

Exemple:

# 遍历列表或元组
for number in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    print(number**2)

# 遍历字符串
for char in "hello world":
    print(char.upper())

# 遍历字典
d = {
      
      'apple': 2, 'banana': 3, 'orange': 4}
for key, value in d.items():
    print(key, value)

# 遍历文件内容
with open('file.txt', 'r') as f: 
    for line in f:
        print(line.strip())

boucle while

Syntaxe de base :

while 条件:
    # 循环体
[else]
	# 循环体

Exemple:

fruits = ['apple', 'banana', 'orange', 'grape']
i = 0
while i < len(fruits):
    print(fruits[i])
    i += 1

L' instruction break peut sortir des corps des boucles for et while. Si elle est terminée à partir de la boucle for ou while, tout bloc else de boucle correspondant ne sera pas exécuté.
L'instruction continue est utilisée pour indiquer à Python d'ignorer les instructions restantes dans le bloc de boucle actuel et de continuer avec l'itération suivante de la boucle.
L' instruction pass est une instruction vide destinée à maintenir l'intégrité de la structure du programme. pass ne fait rien et est généralement utilisée comme instruction d'espace réservé.

Capture et gestion des exceptions (essayer-sauf-finalement)

instruction try et instruction except : utilisées pour intercepter et gérer les exceptions
- Instruction try : contient un bloc de code qui peut lever une exception. Si tryune exception se produit dans le bloc de code, le programme passera immédiatement au exceptbloc de code pour effectuer des opérations de gestion des exceptions.
- Instruction except : dans l' exceptinstruction except, l'objet exception est affecté à une variable e, qui peut être utilisée pour obtenir des informations sur l'exception.
- Instruction else : vous pouvez utiliser l' elseinstruction else pour spécifier un bloc de code à exécuter lorsqu'aucune exception ne se produit.
enfin instruction : spécifie un bloc de code qui doit être exécuté, qu'une exception se produise ou non
Exceptions personnalisées : des classes d'exceptions personnalisées peuvent être créées pour lancer et intercepter des exceptions en fonction des exigences de l'application.

Exemple de code :

# 自定义异常类
class MyCustomError(Exception):
    pass

try:  # 可能会引发异常的代码块
    if some_condition:
        raise MyCustomError("This is a custom error")	# 抛出自定义异常
    result = 10 / 0  # 除以零会引发一个异常
except MyCustomError as e:  # 处理自定义异常
    print(f"Custom error occurred: {
        
        e}")
except ZeroDivisionError as e:
    print(f"Division by zero error: {
        
        e}")
except Exception as e:
    print(f"An error occurred: {
        
        e}")
else:  # 当没有异常发生时要执行的代码块
    print(f"Result is {
        
        result}")
finally:  # 无论是否发生异常都必须执行的代码块
    print("This code always runs")