= Quelques exercices de programmation classiques =

== Échauffement ==

Après :
{{{#!highlight python
a = 1
b = 2
a = b
b = a
}}}
que valent `a` et `b` ?

Ce qui suit est une astuce pythonesque :
{{{#!highlight python
a = 1
b = 2
a,b = b,a
}}}
Pouvez-vous expliquer la différence ?

== Fonctions de base ==


Écrivez une fonction :
{{{#!highlight python
def moy(a,b):
	...
}}}
qui renvoie la moyenne des arguments (en supposant qu’il s’agit de nombres).

Écrivez une fonction :
{{{#!highlight python
def max2(a, b):
	...
}}}
qui renvoie le plus grand des arguments (en supposant que ces arguments peuvent être comparés avec `<`).


À l’aide de `max2`, écrivez une fonction
{{{#!highlight python
def max3(a, b, c):
	...
}}}
qui renvoie le plus grand des arguments parmi trois.


Écrivez une fonction :
{{{#!highlight python
def mediane(a, b, c):
	...
}}}
qui renvoie l’élément médian.


== Boucles ==

Voici une fonction qui calcule quelque chose :
{{{#!highlight python
def f(n,x):
	from math import floor
	y = floor(x)
	x = x-y
	for i in range(n):
		x=1/x
		y=floor(x)
		x = x-y
	return y
}}}

Sans rien comprendre à ce que fait cette fonction,
vous devriez pouvoir en écrire une qui fait exactement la même chose, en
utilisant une boucle `while` au lieu de la boucle `for`.

Voici une autre fonction :
{{{#!highlight python
def g(x,y):
	r=x
	q=0
	while r>=y:
		r = r-y
		q = q+1
	return q,r
}}}
Essayez de deviner ce que renvoie `g(5,2)`, puis vérifiez. Même question pour `g(0,2)`, puis `g(100,3)`.
Que fait `g(1,0)` ? Et finalement que fait `g(x,y)` quand `x` et `y` sont des entiers positifs et `y` est non nul.
Savez-vous le prouver ?


== Un peu d’arithmétique ==

Écrivez une fonction :
{{{#!highlight python
def fact(n):
	...
}}}
qui renvoie la factorielle de l’entier naturel `n`.

Écrivez une fonction :
{{{#!highlight python
def est_premier(n):
	...
}}}
qui renvoie `True` si l’entier naturel `n` est premier et `False` sinon
(on ne vous demande pas quelque chose d’astucieux ou d’efficace).


Écrivez une fonction :
{{{#!highlight python
def nb_premiers(n):
	...
}}}
qui renvoie le nombre de nombres premiers strictement inférieurs à `n`.

Écrivez une fonction :
{{{#!highlight python
def premier_suivant(n):
	...
}}}
qui renvoie le premier nombre premier strictement supérieur à `n`.

Écrivez une fonction :
{{{#!highlight python
def premier_numéro(n):
	...
}}}
qui renvoie le `n`-ième nombre premier.

Écrivez une fonction :
{{{#!highlight python
def pgcd(p,q):
	...
}}}
qui renvoie le PGCD des entiers `p` et `q`.

== Sommes ==

Écrivez une fonction :
{{{#!highlight python
def somme_1(n):
	...
}}}
qui renvoie la somme des entiers naturels de 1 à `n`.

Écrivez une fonction :
{{{#!highlight python
def somme_2(n):
	...
}}}
qui renvoie la somme des carrés des entiers naturels de 1 à `n`.

Écrivez une fonction :
{{{#!highlight python
def somme_k(k,n):
	...
}}}
qui renvoie la somme des puissances `k`-ièmes des entiers naturels de 1 à `n`.


Écrivez une fonction :
{{{#!highlight python
def somme_f(f,n0,n1):
	...
}}}
qui renvoie la somme des valeurs de `f(n)` pour `n0 <= n <= n1`.
Notez que le deuxième argument attendu est une fonction, ce qui ne pose aucun problème à python:
c’est une valeur comme les autres.

Testez par exemple :
{{{#!highlight python
def identite(x):
	return x
def carre(x):
	return x*x
somme_f(identite,0,10)==somme_1(10)
somme_f(carre,0,10)==somme_2(10)
}}}

Écrivez une fonction :
{{{#!highlight python
def integrale(f,x0,x1,n):
	...
}}}
qui calcule une valeur approchée de l’intégrale de `f` sur l’intervalle `[x0,x1]` en suivant la [[https://fr.wikipedia.org/wiki/M%C3%A9thode_des_trap%C3%A8zes|méthode des trapèzes]], avec `n+1` subdivisions.

== La suite ==

À partir de ce point, les boucles ne devraient plus avoir de secrets pour vous. Travaillons sur des structures de données séquentielles : [[Autour des listes]].