Là encore, Python et C sont proches. Par exemple ces deux programmes sont équivalents :

# python
s = 0
while s < 15:
     s += 7

// C
int s = 0;
while (s < 15) {
    s += 5;
}

Comme en Python, on a le droit aux commandes break et continue.

Prenons un exemple complet :

# premier.py
# programme c testant si un nombre est premier
s = int(input("nombre à tester ? "))
d = 2
while d < s:
    if s % d == 0:
        break
    d += 1
if d < s:
    print("{} est divisible par {}.".format(s,d))
else:
    print("{} est premier.".format(s))

// premier.c
// programme c testant si un nombre est premier
// il faut appeler le programme avec en argument le nombre à tester
// par exemple : exemple.exe 45
#include<stdio.h>
#include<stdlib.h>

int main(int argc, const char* argv[])
{
    if (argc < 2){
        printf("Vous devez écrire un nombre en argument. Par ex : premier.exe 45\n");
        return 1;
    }
    int s = atoi(argv[1]);
    int d = 2;
    while (d < s){
        if (s % d == 0){
            // diviseur trouvé
            break;
        }
        d++;
    }
    if (d < s){
        printf("%d est divisible par %d.\n", s, d);
    } else {
        printf("%d est premier.\n", s);
    }
    return 0;
}

• Le principe ici est d'entrer une valeur, par exemple 45. Ce sera la valeur de s. Puis on cherche un diviseur d en partant de 2 (int d = 2) puis en augmentant (d++).
• Quand on trouve un diviseur (s % d == 0), on interrompt la boucle while grâce à la commande break. Le break fait passer à la première commande après la boucle while.
• Sinon d++, équivalent à d +=1 ou encore d = d + 1, permet de passer à la valeur suivante.
• Au pire, si on ne trouve pas de diviseur, d finit par devenir égal à s est la boucle s'arrête.
• Lors du test final, si d < s c'est que l'on a trouvé un diviseur. Sinon, on en a pas trouvé et on peut s'arrêter.

Dans la plupart des cas, une bonne utilisation des return permet de ne pas avoir besoin de break. Voici un exemple :

// premier.c
// programme c testant si un nombre est premier
// il faut appeler le programme avec en argument le nombre à tester
// par exemple : exemple.exe 45
#include<stdio.h>
#include<stdlib.h>

int main(int argc, const char* argv[])
{
    if (argc < 2){
        printf("Vous devez écrire un nombre en argument. Par ex : premier.exe 45\n");
        return 1;
    }
    int s = atoi(argv[1]);
    int d = 2;
    while (d < s){
        if (s % d == 0){
            // diviseur trouvé
            printf("%d est divisible par %d.\n", s, d);
            return 0;
        }
        d++;
    }
    printf("%d est premier\n", s);
    return 0;
}

Dans ce cas, le premier return fait sortir de la fonction main et donc fait sortir aussi du while. On procède ainsi aussi souvent que possible afin d'alléger le code.

En Python, la boucle for est toujours une énumération dans une liste.

Par exemple, si je veux calculer la somme des nombres de 1 à 100 j'écrirai :

# python
somme = 0
for i in range(1,101):
    somme += i
print(somme)

range(1,101) crée une sorte de liste qui contient les nombres de 1 à 100.

note : je rappelle qu'en Python, range exclut toujours la dernière valeur. range(1,101) signifie de 1 à 101, 101 exclus.

Donc la structure for ... in ... consiste à parcourir les éléments d'une liste. D'ailleurs, en Python, on pourra utiliser, comme liste à énumérer, toutes sortes de types de données comme des list, str ou tuple.

En C, voici le programme faisant le même travail :

// C
int somme = 0;
for (int i = 0; i < 101; i++){
    somme += i;
}
printf("%d", somme);

La boucle for fonctionne sur une variable i qui doit être déclarée comme int (elle peut avoir été déclarée avant, pas forcément au début de la boucle comme ici)

On précise la valeur initiale de i, la condition de la boucle i < 101 et enfin le calcul donnant le i suivant. On constate que la boucle for n'est en fait qu'une boucle while spéciale. En effet voici comment passer de l'un à l'autre :

// boucle for
for (int i = 0; i < 101; i++){
    ...
}

// boucle while
int i = 0;
while (i < 101) {
    ...
    i++;
}

Les 3 ingrédients de la boucle forprennent place dans la boucle while.

Cette différence d'approche avec l'énumération est plus manifeste quand on travaille avec un tableau. Vous pouvez aller voir comment sont définis les tableaux en C.

Par exemple en Python :

# python
parents = ["papa", "maman", "tata", "tonton"]
for p in parents:
    print(p)

Dans le tableau parents, l'élément "maman" a l'indice 1. Pour chaque item du tableau on a une paire valeur - indice. Dans le cas de Python, on parcours plutôt les valeurs.

En C :

// C
char* parents[] = {"papa", "maman", "tata", "tonton"};
for (int i = 0; i < 4; i++) {
    p = parents[i];
    printf("%s\n", p);
}

En C, la boucle for parcours les indices. On sait que le tableau contient 4 items, on fait donc aller i de 0 à 3, puis on récupère le contenu du tableau avec p = parents[i].