Passer au contenu
Sujets
  • 1 Commencer
    1.1

    Votre premier programme

    Python exécute votre code ligne par ligne. Chaque ligne est une instruction 语句. Un programme 程序 n'est qu'une liste d'instructions exécutées de haut en bas.

    La fonction print() affiche du texte à l'écran. On appelle cela la sortie 输出. Le texte entre guillemets est une chaîne 字符串.

    print("Hello, world!")
    print("I am learning Python")
    
    • Chaque print() commence une nouvelle ligne.
    • Les guillemets peuvent être "double" ou 'single' — les deux forment une chaîne.
    • Un programme ne fait rien jusqu'à ce que vous l'exécutiez.
    Le code source passe par l'interpréteur pour produire une sortie
    Le code source passe par l'interpréteur pour produire une sortie
    1.2

    Commentaires et style de code

    Un commentaire 注释 commence par #. Python ignore tout après le # sur cette ligne. Les commentaires expliquent votre code aux gens ; ils ne changent pas ce que le code fait.

    # This line is a note for humans
    print("Hi")        # you can also comment at the end of a line
    

    Un bon style rend le code facile à lire :

    • Utilisez des noms clairs qui indiquent ce qu'une valeur signifie.
    • Mettez une instruction par ligne.
    • N'ajoutez pas d'espaces au début d'une ligne normale. En Python, les espaces au début (indentation 缩进) ont une signification spéciale, donc un mauvais espace provoque une erreur 错误.
    1.3

    Entrée, traitement, sortie

    De nombreux programmes suivent un plan simple : entrée 输入 → traitement → sortie. Vous obtenez des données, faites quelque chose avec, puis affichez un résultat.

    La fonction input() lit le texte tapé par l'utilisateur. Elle retourne toujours une chaîne.

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() attend que l'utilisateur tape et appuie sur Entrée.
    • Stockez le texte tapé dans une variable 变量 pour pouvoir l'utiliser plus tard.
    • Comme input() retourne une chaîne, changez-la avec int(...) d'abord si vous avez besoin d'un nombre.

    Erreurs courantes

    • Oublier les guillemets : print(Hello) cherche une variable nommée Hello et soulève une NameError. Le texte nécessite des guillemets : print("Hello").
    • Un espace erroné au début d'une ligne : Python lit l'indentation comme une structure, donc il soulève une IndentationError.
    • Supposer que input() retourne un nombre. Il retourne toujours une chaîne, alors enveloppez-le dans int(...) avant de faire des mathématiques.
  • 2 Variables, types & opérateurs
    2.1

    Variables et affectation

    Une variable 变量 est un nom pour une valeur 值. Vous en créez une avec =, appelé affectation 赋值. Le nom va à gauche ; la valeur va à droite.

    age = 17
    name = "Mei"
    price = 9.99
    print(age, name, price)
    

    Maintenant age contient 17. Utilisez le nom partout où vous avez besoin de la valeur, et changez-la plus tard :

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    Une variable est un nom attaché à une valeur stockée
    Chaque nom de variable pointe vers une valeur en mémoire
    • Le signe = ne signifie pas "égal". Cela signifie "stocker le côté droit sous le nom de gauche".
    • Pour tester si deux valeurs sont égales, utilisez == (voir ci-dessous).
    2.2

    Nombres : int & float

    Python a deux types numériques principaux. Un entier 整数 (int) est un nombre entier comme 17. Un float 浮点数 (float) a un point décimal comme 9.99.

    Ces opérateurs 运算符 fonctionnent sur les nombres :

    Opérateur Signification Exemple Résultat
    + addition 3 + 2 5
    - soustraction 3 - 2 1
    * multiplication 3 * 2 6
    / division (toujours float) 7 / 2 3.5
    // division entière 7 // 2 3
    % reste (modulo) 7 % 2 1
    ** puissance 2 ** 3 8
    • / retourne toujours un float, donc 4 / 2 est 2.0.
    • // et % vont ensemble : 17 // 5 est 3, et 17 % 5 est 2.
    2.3

    Expressions et conversion de type

    Une expression 表达式 est n'importe quoi qui a une valeur, comme 3 + 4 * 2. Python utilise l'ordre mathématique normal (* et / avant + et -) ; ajoutez des parenthèses pour clarifier l'ordre.

    input() retourne une chaîne, donc convertissez-la avant de faire des mathématiques. Changer une valeur d'un type à un autre est la conversion de type 类型转换 :

    age = int("17")        # text "17" -> number 17
    price = float("9.99")  # text -> 9.99
    label = str(17)        # number -> text "17"
    print(age, price, label)
    
    • int("abc") échoue, donc ne convertissez que le texte qui ressemble à un nombre.
    • Mélanger les types échoue aussi : "age: " + 17 est une erreur ; écrivez "age: " + str(17).
    2.4

    Booléens et comparaison

    Un booléen 布尔值 est l'une de seulement deux valeurs : True ou False. Une comparaison 比较 retourne un booléen.

    Opérateur Sens
    == égal à
    != différent de
    < > inférieur / supérieur
    <= >= inférieur / supérieur ou égal
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    Joignez les comparaisons avec and, or, not :

    age = 20
    print(age >= 13 and age <= 19)   # True only for a teenager
    

    Erreurs courantes

    • / retourne toujours un float, même si 4 / 2 est 2.0. Utilisez // quand vous voulez un nombre entier.
    • Utiliser = là où vous entendez dire == : = affecte une valeur, == teste si deux valeurs sont égales.
    • Joindre une chaîne et un nombre : "age: " + 5 soulève une TypeError. Convertissez d'abord avec str(5).
    • Les floats ne sont pas exacts, donc 0.1 + 0.2 n'est pas exactement 0.3 — évitez == sur les résultats de float.
  • 3 Chaînes de Caractères
    3.1

    Indexation

    Une chaîne 字符串 est du texte entre guillemets. Chaque caractère 字符 a une position, appelée son index 索引. Le premier index est 0, pas 1.

    Lisez un seul caractère avec des crochets carrés :

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • Le comptage commence à 0, donc le dernier index est len(word) - 1.
    • Un index négatif compte à rebours depuis la fin : word[-1] est le dernier caractère.
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • Un index trop grand provoque une erreur 错误 (une IndexError).
    s[start:stop] est une fenêtre semi-ouverte de caractères
    s[start:stop] est une fenêtre semi-ouverte de caractères
    3.2

    Tranchage

    Un tranche 切片 prend une partie d'une chaîne. Écrivez word[start:end]. La tranche conserve start mais s'arrête avant end.

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • Omettez start pour commencer à 0 ; omettez end pour aller jusqu'à la fin.
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • Un troisième nombre est le pas 步长. word[::-1] inverse 反转 la chaîne.
    print("Python"[::-1])   # nohtyP
    
    3.3

    Méthodes de chaîne et longueur

    Une méthode 方法 est une fonction qui appartient à une valeur. On l'appelle avec un point :

    name = "mei chen"
    print(name.upper())     # MEI CHEN
    print(name.title())     # Mei Chen
    print(len(name))        # 8
    

    Les chaînes de caractères sont immuables 不可变 : une méthode retourne une chaîne nouvelle et ne modifie jamais l'originale 原始.

    name = "mei"
    print(name.upper())     # MEI  (the returned value)
    print(name)             # mei  (the original is unchanged)
    

    Méthodes courantes (chacune retourne une nouvelle valeur) :

    Méthode Signification Exemple Résultat
    .upper() / .lower() changer la casse "Hi".lower() hi
    .strip() supprimer les espaces aux bords " hi ".strip() hi
    .replace(a, b) inverser le texte "cat".replace("c", "b") bat
    .split(sep) diviser en une liste "a,b".split(",") ['a', 'b']

    Joindre des chaînes avec +. C'est ce qu'on appelle la concaténation 拼接 :

    first = "Mei"
    last = "Chen"
    print(first + " " + last)   # Mei Chen
    
    3.4

    f-strings

    Une f-string 格式化字符串 construit du texte à partir de valeurs. Placez f avant la guillemet, puis écrivez {...} autour d'une valeur.

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • Toute expression 表达式 peut aller entre accolades.
    • {value:.2f} arrondit à 2 décimales 小数位.
    price = 9.5
    print(f"Two cost {price * 2}")        # Two cost 19.0
    print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14
    

    Erreurs courantes

    • Les chaînes ne peuvent pas être modifiées sur place : s[0] = "x" génère une erreur. Créez plutôt une nouvelle chaîne.
    • L'indexation commence à 0 ; le dernier caractère est s[-1], et s[len(s)] est hors limites.
    • Une tranche s[a:b] inclut a mais s'arrête avant b.
    • Les méthodes de chaîne retournent une chaîne NOUVELLE : s.upper() ne fait rien sauf si vous stockez le résultat.
  • 4 Sélection
    4.1

    if / elif / else

    Un programme choisit quoi faire avec if. Il exécute un bloc indenté 缩进 seulement quand une condition 条件 est vraie. La ligne if se termine par deux-points 冒号.

    score = 72
    if score >= 60:
        print("pass")
    # pass
    

    Ajoutez elif (else-if) pour plus de cas et else pour « tout autre ». Python exécute la première branche vraie 分支 uniquement, puis saute le reste.

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • Comparez des valeurs avec == (égal), != (non égal), <, >, <=, >=.
    • Une comparaison 比较 donne une valeur booléenne 布尔值 — soit True, soit False.
    if / elif / else: seule une branche s'exécute
    if / elif / else: seule une branche s'exécute
    4.2

    Combiner des conditions

    Joignez des conditions avec and, or, not. and nécessite que les deux côtés soient vrais ; or nécessite que l'un ou l'autre côté soit vrai ; not inverse une valeur booléenne.

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • Utilisez des parenthèses pour clarifier l'ordre : (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    Erreurs courantes

    • Écrivez elif, pas else if.
    • Chaque ligne if / elif / else se termine par deux-points :, et son corps doit être indenté.
    • if x = 5: est une erreur — utilisez == pour comparer.
    • else ne prend pas de condition ; seuls if et elif en prennent.
  • 5 Itération
    5.1

    Boucles for et range

    Une boucle 循环 répète du code. Une boucle for répète une fois pour chaque élément d'une séquence 序列. range(n) donne les nombres 0 jusqu'à n - 1.

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • range(a, b) va de a jusqu'à (sans inclure) b.
    • range(a, b, step) ajoute un pas 步长 à chaque itération.
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): le corps s'exécute avec i = 0 … n-1
    for i in range(n): le corps s'exécute avec i = 0 … n-1
    5.2

    Le motif de l'accumulateur

    Pour construire un résultat au fil d'une boucle, initialisez une variable avant la boucle, puis mettez-la à jour 更新 à chaque tour. C'est le motif de l'accumulateur 累加器.

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • La même idée compte combien d'éléments correspondent à un test.
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    Boucles while

    Une boucle while répète tant que une condition reste vraie. Changez quelque chose à l'intérieur, sinon elle ne s'arrêtera jamais — une boucle infinie 无限循环.

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • break quitte immédiatement la boucle.
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    Boucles imbriquées

    Une boucle dans une autre boucle est une boucle imbriquée 嵌套循环. La boucle interne 内层循环 s'exécute entièrement pour chaque itération de la boucle externe 外层循环.

    for row in range(3):
        line = ""
        for col in range(3):
            line = line + "*"
        print(line)
    # ***
    # ***
    # ***
    

    Erreurs courantes

    • range(n) va de 0 à n - 1, pas de 1 à n — l'erreur classique off-by-one.
    • Modifier une liste pendant qu'on parcourt sauter des éléments ; parcourez une copie si vous devez supprimer des choses.
    • Oublier de modifier la variable de boucle dans une while la fera tourner indéfiniment.
    • L'indentation détermine ce qui est dans la boucle ; une ligne mal indentée ne s'exécute qu'une seule fois, après la boucle.
  • 6 Listes & listes 2D
    6.1

    Listes

    Une liste contient de nombreuses valeurs ordonnées, à l'intérieur de []. Chaque élément a un index (à partir de 0).

    scores = [88, 71, 95]
    print(scores[0])      # 88
    print(len(scores))    # 3
    scores.append(60)     # add to the end
    print(scores)         # [88, 71, 95, 60]
    
    • Modifiez un élément par son index : scores[1] = 100.
    • Une liste peut grandir et rétrécir ; une chaîne non.

    Les outils courants pour les listes :

    Outil Fait
    a.append(x) ajoute x à la fin
    a.insert(i, x) insère x à la position i
    a.remove(x) supprime le premier x
    a.pop() / a.pop(i) supprime et retourne le dernier élément / l'élément i
    a.sort() trie la liste en place
    sorted(a) retourne une nouvelle liste triée
    x in a est x dans la liste ?
    len(a), sum(a), max(a), min(a) taille et mathématiques rapides
    Les indices de liste commencent à 0
    Les indices de liste commencent à 0
    6.2

    Parcourir une liste

    Parcourir une liste consiste à visiter chaque élément. Une boucle for fait cela sans index nécessaire.

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • Utilisez enumerate quand vous avez aussi besoin de l'index.
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    Listes 2-D (grilles)

    Une liste 2-D est une liste de listes — une grille de lignes et colonnes. Utilisez deux indices : grid[row][col].

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • Une boucle imbriquée visite chaque cellule.
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

    Compréhensions de liste

    Une compréhension de liste construit une nouvelle liste en une seule ligne : [expression for item in sequence].

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • Ajoutez if pour ne garder que certains éléments.
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    Tuples & ensembles

    Un tuple est une séquence fixe entre parenthèses rondes. Il ne peut pas être modifié après sa création — utilisez-le pour des valeurs qui appartiennent ensemble, et décompactez-le en noms.

    point = (3, 4)
    x, y = point            # unpacking
    print(x, y)             # 3 4
    

    Une fonction devant retourner deux résultats retourne un tuple :

    def min_max(nums):
        return min(nums), max(nums)
    
    lo, hi = min_max([5, 2, 9])
    print(lo, hi)           # 2 9
    

    Un ensemble stocke chaque valeur une seule fois, sans ordre. Il est parfait pour supprimer les doublons et pour des tests d'appartenance rapides.

    votes = ["red", "blue", "red", "green", "red"]
    colours = set(votes)
    print(len(colours))         # 3  (duplicates removed)
    print("blue" in colours)    # True
    

    Erreurs courantes

    • b = a partage une même liste. a.copy() ou a[:] crée une nouvelle liste externe, mais les éléments mutables imbriqués restent partagés (copie peu profonde).
    • Le dernier élément est a[-1] ; a[len(a)] est hors limites.
    • append ajoute UN seul élément ; utilisez extend ou + pour joindre une autre liste.
    • Construire une grille avec [[0]*3]*3 crée trois copies de la même ligne. Construisez les lignes dans une boucle à la place.
    • Un tuple avec un seul élément a besoin d'une virgule : (5,), pas (5).
    • Un set n'a ni ordre ni doublons, donc on ne peut pas l' indexer avec s[0].
  • 7 Dictionnaires
    7.1

    Dictionnaires

    Un dictionnaire 字典 (dict) stocke des paires clé 键 → valeur 值. On cherche une valeur par sa clé, pas par un index numérique.

    student = {"name": "Mei", "score": 88}
    print(student["name"])     # Mei
    print(student["score"])    # 88
    

    Ajouter et mettre à jour

    Attribuez à une clé pour l'ajouter, ou pour modifier une existante.

    student = {"name": "Mei"}
    student["score"] = 88      # add a new key
    student["score"] = 90      # update the value
    print(student)             # {'name': 'Mei', 'score': 90}
    

    Vérifier et parcourir

    Utilisez in pour tester l'existence d'une clé. Parcourez les clés, ou .items() pour obtenir à la fois clé et valeur.

    student = {"name": "Mei", "score": 90}
    print("score" in student)  # True
    for key, value in student.items():
        print(key, "=", value)
    # name = Mei
    # score = 90
    
    • .get(key, default) retourne une valeur par défaut 默认值 quand la clé manque — aucune erreur.
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    Le motif d'examen classique — compter la fréquence d'apparition de chaque valeur :

    word = "banana"
    counts = {}
    for letter in word:
        counts[letter] = counts.get(letter, 0) + 1
    print(counts)   # {'b': 1, 'a': 3, 'n': 2}
    
    • .get(letter, 0) fournit 0 la première fois qu'une clé est vue, évitant un KeyError.

    Erreurs courantes

    • Lire une clé manquante avec d[key] lève un KeyError ; utilisez d.get(key) ou testez if key in d d'abord.
    • Attribuer d[key] à nouveau écrase l'ancienne valeur — les clés sont uniques.
    • Les clés doivent être immuables, comme une chaîne ou un nombre — une liste ne peut pas être une clé.
    Un dictionnaire mappe chaque clé vers une valeur
    Un dictionnaire mappe chaque clé vers une valeur
  • 8 Fonctions & abstraction
    8.1

    Définir & appeler des fonctions

    Une fonction 函数 est un bloc de code nommé réutilisable. Définissez 定义-la avec def, puis appelez 调用-la par nom.

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • Le code à l'intérieur ne s'exécute que lorsque vous appelez la fonction.
    def définit ; appel exécute ; return renvoie une valeur
    def définit ; appel exécute ; return renvoie une valeur
    8.2

    Valeurs de retour

    Une fonction peut retourner 返回 une valeur avec return. L'appel devient alors cette valeur.

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • return arrête immédiatement la fonction. Une fonction sans return retourne None.
    8.3

    Paramètres, arguments & portée

    Un paramètre 形参 est le nom dans la def. Un argument 实参 est la valeur que vous passez.

    def power(base, exp):         # base, exp are parameters
        return base ** exp
    
    print(power(2, 3))            # 8  (2 and 3 are arguments)
    

    Une variable créée à l'intérieur d'une fonction est locale 局部 — elle n'existe que là. Cette région est sa portée 作用域.

    def f():
        x = 10            # local to f
        return x
    
    print(f())            # 10
    # print(x) here would be an error: x is not defined outside f
    

    Un paramètre peut avoir une valeur par défaut 默认值, utilisée quand l'appelant l'ommet :

    def greet(name, greeting="Hello"):
        return greeting + ", " + name
    
    print(greet("Mei"))              # Hello, Mei
    print(greet("Sam", "Welcome"))   # Welcome, Sam
    
    8.4

    Abstraction procédurale

    L'abstraction procédurale 过程抽象 signifie cacher les détails derrière un nom. Vous utilisez une fonction par son nom et ce qu'elle fait, pas comment elle fonctionne.

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • Une bonne fonction fait une seule tâche, a un nom clair, et évite de répéter du code.
    8.5

    Modules & imports

    Un module 模块 est un fichier de fonctions prêtes. Importez-en un avec import 导入.

    import random
    random.seed(0)               # makes the result repeatable
    print(random.randint(1, 6))  # a dice roll
    
    import math
    print(math.sqrt(16))         # 4.0
    

    Erreurs courantes

    • Une fonction retourne None sauf si vous écrivez return. Imprimer n'est pas pareil que retourner.
    • N'utilisez jamais une valeur par défaut mutable comme def f(x=[]) — la même liste est partagée entre tous les appels.
    • Une variable créée à l'intérieur d'une fonction est locale et invisible à l'extérieur.
    • Exécutez une fonction avec f() ; écrire f seul nomme simplement la fonction.
  • 9 Erreurs, exceptions & tests
    9.1

    Erreurs & débogage

    Le code peut échouer de trois manières. Une erreur de syntaxe viole les règles de Python, il ne s'exécute jamais. Une erreur d'exécution survient pendant l'exécution, comme une division par zéro. Une erreur logique s'exécute mais produit une réponse incorrecte.

    Erreurs Python courantes : Syntaxe, Nom, Type, Index
    Erreurs Python courantes : Syntaxe, Nom, Type, Index
    # A runtime error, caught so this block still finishes:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("cannot divide by zero")
    # cannot divide by zero
    
    • Python affiche une traceback indiquant où l'échec a eu lieu. Lisez-la de bas en haut.
    9.2

    try / except / raise

    Placez le code risqué dans try ; si celui-ci échoue, except intercepte l'exception au lieu d'un crash.

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • Attrapez un type spécifique (ValueError, ZeroDivisionError, …).
    • raise génère volontairement votre propre erreur.
    def set_age(age):
        if age < 0:
            raise ValueError("age cannot be negative")
        return age
    
    try:
        set_age(-1)
    except ValueError as err:
        print("error:", err)
    # error: age cannot be negative
    
    9.3

    Tests & robustesse

    Un test vérifie que le code produit la bonne réponse. Testez les cas normaux et les cas limites — entrée vide, zéro, très grandes valeurs.

    def average(nums):
        if len(nums) == 0:        # edge case: empty list
            return 0
        return sum(nums) / len(nums)
    
    print(average([2, 4, 6]))     # 4.0
    print(average([]))            # 0
    
    • Un code robuste gère les entrées étranges avec élégance au lieu de planter.

    Erreurs courantes

    • N'utilisez pas un simple except: — capturez l'erreur spécifique, par exemple except ValueError:.
    • Une erreur de syntaxe arrête tout le programme avant son exécution, corrigez donc celles-ci en premier.
    • Testez les cas limites (entrée vide, zéro, valeur maximale), pas seulement le cas facile.
  • 10 Fichiers
    10.1

    Lecture et écriture de fichiers texte

    Un fichier texte 文本文件 stocke du texte sur le disque. Ouvrez-le avec open(name, mode) où mode 模式 indique la lecture ou l'écriture. Utilisez toujours with, qui ferme le fichier pour vous.

    Écriture

    Le mode "w" écrit un nouveau fichier et efface l'ancien.

    with open("notes.txt", "w") as f:
        f.write("first line\n")
        f.write("second line\n")
    print("saved")            # saved
    

    Lecture

    Le mode "r" (par défaut) lit. .read() retourne tout le fichier comme une seule chaîne.

    with open("notes.txt", "w") as f:
        f.write("hello\nworld\n")
    with open("notes.txt") as f:
        print(f.read().strip())   # hello / world
    

    Ligne par ligne

    Parcourez le fichier pour obtenir une ligne à la fois. .strip() retire 去除 le caractère de nouvelle ligne 换行符 à la fin.

    with open("data.txt", "w") as f:
        f.write("Mei,88\nSam,71\n")
    with open("data.txt") as f:
        for line in f:
            name, score = line.strip().split(",")
            print(name, "scored", score)
    # Mei scored 88
    # Sam scored 71
    

    Ajout

    Le mode "a" ajoute 追加 à la fin sans effacer.

    with open("log.txt", "w") as f:
        f.write("line 1\n")
    with open("log.txt", "a") as f:
        f.write("line 2\n")
    with open("log.txt") as f:
        print(f.read().strip())   # line 1 / line 2
    
    Mode Signification
    "r" lecture (par défaut)
    "w" écriture (efface d'abord)
    "a" ajout (ajoute à la fin)

    Erreurs courantes

    • Fermez toujours un fichier, ou utilisez with open(...) as f: qui le ferme pour vous.
    • read() retourne tout le fichier comme une seule chaîne, et chaque ligne se termine encore par \n.
    • Ouvrir avec "w" efface d'abord le fichier ; utilisez "a" pour ajouter à la fin.
    open → read/write → close (with auto-closes)
    open → read/write → close (with auto-closes)
  • 11 Conception d'algorithme
    11.1

    Algorithmes et décomposition

    Un algorithme est une liste claire d'étapes résolvant un problème. La décomposition consiste à découper un grand problème en petites parties que l'on peut résoudre les unes après les autres.

    # Algorithm: find the largest number in a list
    def largest(nums):
        best = nums[0]
        for n in nums:
            if n > best:
                best = n
        return best
    
    print(largest([3, 9, 2, 7]))   # 9
    
    • L'abstraction signifie ignorer les détails : vous utilisez le largest(...) sans avoir à relire son fonctionnement interne.
    11.2

    Pseudocode et diagrammes de flux

    Le pseudocode est un anglais structuré simple pour un algorithme, écrit avant le vrai code. Il n'est pas exécuté.

    SET best TO first number
    FOR Each number n
        IF n > best
          THEN
            SET best TO n
    OUTPUT best
    

    Un organigramme dessine le même plan : une boîte pour chaque étape, un losange pour chaque décision, et des flèches pour l'ordre.

    11.3

    Récursivité et pile d'appels

    La récursion se produit lorsqu'une fonction s'appelle elle-même. Elle nécessite un cas de base (une entrée simple qui retourne immédiatement) et un cas récursif (elle s'appelle elle-même sur une entrée plus petite).

    La pile d'appels pour factorial(3) : chaque appel attend, puis retourne dans l'ordre inverse
    La pile d'appels pour factorial(3) : chaque appel attend, puis retourne dans l'ordre inverse
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • Chaque appel en pause repose sur la pile d'appels jusqu'à ce que l'appel supérieur retourne.

    Erreurs courantes

    • La récursivité a besoin d'un cas de base, sinon elle s'appelle éternellement et fait déborder la pile d'appels.
    • Le pseudocode sert à planifier — il n'a pas besoin de s'exécuter, mais chaque étape doit être sans ambiguïté.
    • Divisez un grand problème en petites étapes nommées avant d'écrire du code.
  • 12 Structures de données
    12.1

    Types de Données Abstraits (ADT)

    Un type de données abstrait 抽象数据类型 (ADT) décrit des données ainsi que les opérations dessus, séparément de sa mise en œuvre. Vous l'utilisez via ses opérations, pas via son stockage interne.

    # A stack ADT, built on a list
    s = []
    s.append(1)        # add
    s.append(2)
    print(s.pop())     # 2  (remove the most recent)
    
    12.2

    Piles

    Une pile 栈 est Last-In-First-Out (LIFO 后进先出). Vous empilez 压入 sur le dessus et dépilez 弹出 depuis le dessus.

    Une pile retire depuis le haut (LIFO) ; une file retire depuis l'avant (FIFO)
    Une pile retire depuis le haut (LIFO) ; une file retire depuis l'avant (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    Fichiers

    Une file 队列 est First-In-First-Out (FIFO 先进先出). Vous insérez 入队 à l'arrière et retirez 出队 depuis l'avant.

    queue = []
    queue.append("a")     # enqueue
    queue.append("b")
    print(queue.pop(0))   # a  (dequeue the front)
    print(queue.pop(0))   # b
    
    12.4

    Listes chainées

    Une liste chaînée 链表 est une chaîne de nœuds 节点. Chaque nœud contient des données et un pointeur 指针 vers le nœud suivant ; le dernier pointe vers None.

    Une liste chaînée : chaque noeud contient des données et un pointeur vers le noeud suivant, se terminant par None
    Une liste chaînée : chaque noeud contient des données et un pointeur vers le noeud suivant, se terminant par None
    n3 = {"data": 3, "next": None}
    n2 = {"data": 2, "next": n3}
    n1 = {"data": 1, "next": n2}
    node = n1
    while node is not None:      # traverse to the end
        print(node["data"])
        node = node["next"]
    # 1 2 3
    
    12.5

    Tables de hachage

    Une table de hachage 哈希表 associe une clé à une case via une fonction de hachage 哈希函数. Deux clés peuvent atterrir dans la même case — c'est une collision 冲突. Python's dict est une table de hachage, donc la recherche est rapide.

    Une fonction de hachage mappe chaque clé à un emplacement ; deux clés peuvent entrer en collision dans un même emplacement
    Une fonction de hachage mappe chaque clé à un emplacement ; deux clés peuvent entrer en collision dans un même emplacement
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    Arbres binaires de recherche

    Un arbre binaire de recherche 二叉搜索树 (BST) maintient l'ordre : chaque enfant gauche est plus petit que son nœud, chaque enfant droit est plus grand. La recherche reste rapide.

    Un arbre binaire de recherche : les valeurs plus petites vont à gauche, les plus grandes à droite
    Un arbre binaire de recherche : les valeurs plus petites vont à gauche, les plus grandes à droite
    def insert(root, val):
        if root is None:
            return {"val": val, "left": None, "right": None}
        if val < root["val"]:
            root["left"] = insert(root["left"], val)
        else:
            root["right"] = insert(root["right"], val)
        return root
    
    def inorder(root):
        if root is None:
            return []
        return inorder(root["left"]) + [root["val"]] + inorder(root["right"])
    
    tree = None
    for v in [5, 3, 8, 1, 4]:
        tree = insert(tree, v)
    print(inorder(tree))   # [1, 3, 4, 5, 8]
    
    12.7

    Graphes

    Un graphe 图 est un ensemble de sommets 顶点 joints par des arêtes 边. Une liste d'adjacence 邻接表 — un dictionnaire de listes de voisins — est une méthode courante pour le stocker.

    Un graphe de sommets et d'arêtes, avec sa forme de liste d'adjacence
    Un graphe de sommets et d'arêtes, avec sa forme de liste d'adjacence
    graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
    for vertex in graph:
        print(vertex, "->", graph[vertex])
    # A -> ['B', 'D']  (and so on for B, C, D)
    

    Erreurs courantes

    • Une pile est Last-In-First-Out ; une file est First-In-First-Out. Ne les mélangez pas.
    • Vérifiez si une structure est vide avant de dépiler ou de retirer de la file.
    • Dans une liste chaînée, perdre le pointeur head fait perdre toute la liste.
  • 13 Recherche, tri & efficacité
    13.1

    Recherche linéaire et binaire

    Une recherche 查找 trouve où se trouve une valeur. La recherche linéaire 线性查找 vérifie chaque élément à tour de rôle, donc elle fonctionne sur n'importe quelle liste.

    def linear_search(items, target):
        for i in range(len(items)):
            if items[i] == target:
                return i
        return -1     # not found
    
    print(linear_search([4, 8, 2, 9], 2))   # 2
    

    La recherche dichotomique 二分查找 est beaucoup plus rapide mais nécessite une liste triée. Elle divise la plage par deux à chaque étape.

    def binary_search(items, target):
        lo, hi = 0, len(items) - 1
        while lo <= hi:
            mid = (lo + hi) // 2
            if items[mid] == target:
                return mid
            elif items[mid] < target:
                lo = mid + 1
            else:
                hi = mid - 1
        return -1
    
    print(binary_search([1, 3, 5, 7, 9], 7))   # 3
    
    La recherche dichotomique divise la plage par deux à chaque étape — O(log n) sur une liste triée
    La recherche dichotomique divise la plage par deux à chaque étape — O(log n) sur une liste triée
    13.2

    Tri (bulle et insertion)

    Trier 排序 consiste à mettre les éléments dans l'ordre. Le tri bulle 冒泡排序 échange répétitivement les voisins qui sont dans le mauvais ordre.

    def bubble_sort(a):
        a = a[:]                          # work on a copy
        for i in range(len(a)):
            for j in range(len(a) - 1 - i):
                if a[j] > a[j + 1]:
                    a[j], a[j + 1] = a[j + 1], a[j]
        return a
    
    print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]
    

    Le tri par insertion 插入排序 construit une partie triée un élément à la fois, glissant chaque nouvel élément à sa place :

    def insertion_sort(a):
        a = a[:]                           # work on a copy
        for i in range(1, len(a)):
            key = a[i]
            j = i - 1
            while j >= 0 and a[j] > key:   # shift bigger values right
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = key                 # drop key into the gap
        return a
    
    print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]
    
    • En code réel, utilisez le built-in Python sorted() :
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    Efficacité algorithmique

    L'efficacité 效率 examine comment le travail augmente lorsque l'entrée augmente. Nous la décrivons avec la notation Big-O 大O记号.

    Comment le nombre d'étapes croît avec la taille de l'entrée pour les complexités courantes
    Comment le nombre d'étapes croît avec la taille de l'entrée pour les complexités courantes
    Big-O Nom Exemple
    $O(1)$ constant look up a dict key
    $O(\log n)$ logarithmique binary search
    $O(n)$ linéaire linear search
    $O(n^2)$ quadratique bubble sort
    def steps(n):           # how many steps a linear scan takes
        count = 0
        for i in range(n):
            count = count + 1
        return count
    
    print(steps(100))       # 100  -> O(n)
    
    13.4

    Aléatoire et simulation

    Le module random génère des nombres aléatoires. Utilisez une graine 种子 pour rendre les résultats reproductibles. Une simulation 模拟 exécute de nombreux essais aléatoires pour estimer une réponse.

    import random
    random.seed(0)
    rolls = [random.randint(1, 6) for _ in range(1000)]
    print(rolls.count(6))   # about 1/6 of 1000
    

    Erreurs courantes

    • La recherche dichotomique ne fonctionne que sur une liste triée.
    • Big-O vous dit comment le temps CROÎTRAIT, pas le temps exact ; une méthode O(n²) bat O(n) seulement pour de minuscules entrées.
    • Le tri bulle est O(n²) — bien pour apprendre, mais lent sur de grandes listes.
  • 14 POO & paradigmes
    14.1

    Classes et objets

    Une classe est un modèle. Un objet est une entité construite à partir de celui-ci (une instance). __init__ est le constructeur qui initialise chaque objet ; self est l'objet lui-même.

    class Dog:
        def __init__(self, name):
            self.name = name            # an attribute
        def speak(self):
            return self.name + " says woof"
    
    d = Dog("Rex")
    print(d.speak())     # Rex says woof
    
    • name est un attribut (données sur l'objet) ; speak est une méthode (une action).

    Ajoutez __str__ pour contrôler ce que montre print(obj) :

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    Une classe est un modèle ; son appel crée un objet
    Une classe est un modèle ; son appel crée un objet
    14.2

    Héritage, encapsulation et polymorphisme

    L'héritage permet à une sous-classe de réutiliser une superclasse. Utilisez super() pour appeler le parent ; redéfinissez une méthode pour la modifier.

    class Animal:
        def speak(self):
            return "some sound"
    
    class Cat(Animal):
        def speak(self):                # override
            return "meow"
    
    print(Cat().speak())   # meow
    

    L'encapsulation regroupe les données avec les méthodes et expose une interface prévue. En Python, un underscore initial marque un nom intentionnellement non public (souvent appelé privé) par convention ; cela n'empêche pas le code externe de y accéder. Le manglement de noms à double underscore aide à éviter les conflits accidentels de noms entre sous-classes, mais ne sert pas à imposer la sécurité.

    class Account:
        def __init__(self):
            self._balance = 0           # non-public by convention
        def deposit(self, n):
            self._balance += n
        def balance(self):
            return self._balance
    
    a = Account()
    a.deposit(50)
    print(a.balance())     # 50
    

    Le polymorphisme signifie un seul nom, plusieurs comportements : le bon speak s'exécute pour chaque objet.

    class Cat:
        def speak(self):
            return "meow"
    
    class Cow:
        def speak(self):
            return "moo"
    
    for animal in [Cat(), Cow()]:
        print(animal.speak())   # meow, then moo
    
    14.3

    Paradigmes de programmation

    Un paradigme est un style d'écriture de programmes. Le code procédural est une séquence d'étapes et de fonctions. Le code orienté objet regroupe les données et les méthodes dans des objets. Le code déclaratif dit ce que vous voulez, pas comment (une compréhension de liste ou SQL).

    def total(nums):           # procedural
        t = 0
        for n in nums:
            t += n
        return t
    print(total([1, 2, 3]))    # 6
    
    print(sum([1, 2, 3]))      # 6  (declarative: same result)
    

    Erreurs courantes

    • Chaque méthode a besoin de self comme premier paramètre.
    • __init__ met en place un nouvel objet et s'exécute automatiquement lors de sa création.
    • Deux objets de la même classe ont des attributs séparés ; modifier l'un ne modifie pas l'autre.
  • 15 Représentation des données
    15.1

    Bits et binaire

    Un bit 比特 est un seul 0 ou 1. Le binaire 二进制 est le système numérique base-2 : chaque position vaut le double de celle de droite (1, 2, 4, 8, …). Le décimal 十进制 (base-10) correspond à nos nombres habituels.

    Binary place values: 1101 means 8 + 4 + 1 = 13
    Binary place values: 1101 means 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 bits font un octet 字节. Une largeur fixe peut déborder 溢出 (s'enrouler) lorsque le nombre est trop grand.
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    L'hexadécimal 十六进制 (base 16) est une façon compacte de lire le binaire : un chiffre hexadécimal représente exactement quatre bits. Python écrit l'hexadécimal avec 0x :

    print(hex(255))        # 0xff
    print(0xFF)            # 255
    print(int("ff", 16))   # 255
    
    15.2

    Compression

    La compression 压缩 rend les données plus petites. La compression sans perte 无损 compression conserve tous les bits, permettant de reconstruire l'original exactement. La compression avec perte 有损 compression jette des détails — plus petite mais pas exacte — et est utilisée pour les photos et la musique.

    Le codage par longueur de run 游程编码 est une simple méthode sans perte : stocker un run 游程 (une répétition) comme un compteur suivi de la valeur.

    def rle(text):
        out = ""
        i = 0
        while i < len(text):
            run = 1
            while i + run < len(text) and text[i + run] == text[i]:
                run += 1
            out += str(run) + text[i]
            i += run
        return out
    
    print(rle("AAAABBBCCD"))   # 4A3B2C1D
    

    Erreurs courantes

    • n bits stockent 2**n valeurs différentes, de 0 à 2**n - 1.
    • La compression avec perte jette des détails et ne peut pas être annulée ; la sans perte peut être inversée exactement.
  • 16 Concepts informatiques
    16.1

    Ce qu'est l'informatique et le cycle de conception

    L'informatique 计算 signifie résoudre des problèmes avec des ordinateurs : entrée, traitement, sortie. Un bon logiciel est construit selon un cycle de conception 设计循环 — planifier, écrire, tester, améliorer — répété de nombreuses fois.

    • Décomposez un problème, construisez une petite partie, testez-la, puis ajoutez-en davantage.
    • Les programmeurs travaillent en équipe et réutilisent le code les uns des autres.
    16.2

    Internet

    Internet 互联网 est un réseau 网络 de réseaux. Les données sont découpées en paquets 数据包 qui circulent séparément et sont reconstitués à l'autre extrémité. Des règles partagées appelées protocoles 协议 (comme TCP/IP) rendent cela possible. Si un chemin est interrompu, les paquets empruntent une autre voie — c'est la redondance 冗余, qui confère une tolérance aux pannes 容错.

    Une carte d'Internet : chaque ligne représente un chemin entre deux réseaux
    Une carte d'Internet : chaque ligne représente un chemin entre deux réseaux
    Couche Rôle
    HTTP demande et envoie des pages web
    TCP livraison fiable, dans l'ordre
    IP adressage et routage
    16.3

    Calcul parallèle et distribué

    Le code séquentiel 顺序 effectue une étape à la fois. Le calcul parallèle 并行 effectue plusieurs étapes simultanément sur de nombreux cœurs 核心, ce qui peut apporter un gain de performance 加速. Le calcul distribué 分布式 répartit la charge de travail sur plusieurs ordinateurs, comme dans le cloud.

    • Tout ne peut pas s'exécuter en parallèle : certaines étapes doivent attendre un résultat antérieur.
    16.4

    Impact du calcul

    Le calcul apporte à la fois des avantages et des inconvénients. La fracture numérique 数字鸿沟 signifie que tout le monde n'a pas un accès égal. Les logiciels peuvent contenir des biais 偏见 tirés des données dont ils apprennent. Respectez la propriété intellectuelle 知识产权 (licences), et protégez les données personnelles 个人数据 et la vie privée 隐私 des personnes.

    Erreurs courantes

    • Internet et le World Wide Web ne sont pas la même chose : le Web est un service qui fonctionne au-dessus d'Internet.
    • Avoir plus de cœurs de processeur n'est utile que si la tâche peut être divisée en parties exécutables simultanément.
  • 17 Tout mettre ensemble
    17.1

    Mini-projets de bout en bout

    Un mini-projet 小项目 combine les notions précédentes : des données dans une liste, une fonction avec une sélection dans une boucle, et une sortie imprimée. C'est aussi la forme de la Tâche de Performance AP Create.

    Projet : note moyenne

    def average(marks):
        if len(marks) == 0:
            return 0
        return round(sum(marks) / len(marks), 1)
    
    print(average([88, 71, 95, 60]))   # 78.5
    

    Projet : compter les succès

    def count_passes(marks, pass_mark=60):
        passes = 0
        for m in marks:                 # iteration
            if m >= pass_mark:          # selection
                passes += 1
        return passes
    
    print(count_passes([88, 50, 95, 60]))   # 3
    

    Projet : filtrer vers une nouvelle liste

    def merit(marks):
        return [m for m in marks if m >= 80]
    
    print(merit([88, 71, 95, 60]))     # [88, 95]
    

    La Tâche AP Create demande une liste, une procédure paramétrée 过程 utilisant une sélection 选择 et une itération 迭代, ainsi qu'une entrée/sortie. Chacun des projets ci-dessus suit exactement cette structure — construisez des petits morceaux, puis assemblez-les.

    Erreurs courantes

    • Construisez par petites étapes et testez chaque partie avant de passer à la suivante — ne writez pas tout d'un coup.
    • Lisez toute la tâche d'abord, puis planifiez l'entrée → traitement → sortie avant de coder.
    Mini-projet : données → fonction → résultat imprimé
    Mini-projet : données → fonction → résultat imprimé

Se connecter ou créer un compte

IGCSE, A-Level & AP