{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercices courts pour s'entraîner - SUJET"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Sources** : \"Numérique et Sciences Informatique 1er\" - Ellipses et [Coding] N°6, N°12"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ressources** : "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"----\n",
"**Sommaire** \n",
"1. Pour s'échauffer \n",
"2. Chaînes de caractères \n",
"3. Tuples, listes, dictionnaires et ensembles\n",
"----"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Tout comme un musicien fait ses gammes pour s'échauffer et gagner en assurance, un **débutant en programmation Python** gagnera à faire des exercices courts pour se familiariser avec le langage.*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Pour s'échauffer"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> **Exercice 11** - Calcul d'aires\n",
">\n",
">Ecrire un programme qui demande à l'utilisateur les longueurs en mètres des deux côtés d'un rectangle et affiche son aire. Afficher le résultat avec deux décimales.\n",
">\n",
">*Exemple de résultat attendu* \n",
"Entrer la longeur et la largeur du rectangle en mètres \n",
"Longeur ? 5.4 \n",
"Largeur ? 2.3
\n",
"Aire = 12.42 m²"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 12** - Divisible par n ?\n",
">\n",
">Ecrire une fonction **divparn**(lst,n) qui recherche dans une liste **lst** d'entiers positifs les nombres divisibles par **n** $\\in$ N* et les affiche. Le signe * exclu le nombre 0 d'un ensemble. \n",
">\n",
">*Exemple de résultat attendu* \n",
"\n",
"tab=[1,5,42,9,15,9,7,30] et n = 5 => Afficher [5, 15, 30] \n",
"tab=[1,5,42,9,15,9,7,30] et n = 3 => Afficher [42, 9, 15, 9, 30] \n",
"tab=[1,5,42,9,15,9,7,30] et n = 8 => Afficher \"Aucune valeur de la liste n'est divisible par 8\"\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n",
"def divparn(lst,n):\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Chaînes de caractères\n",
"**Ressources** : "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour effectuer des tâches de programmation en Python, une bonne compréhension des chaînes de caractères est nécessaire."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**A faire**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. Tuples, listes, dictionnaires et ensembles"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.1 Tuples\n",
"**Ressources** : "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**A faire**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 Listes\n",
"**Ressources** : "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 321**\n",
">\n",
"> Ecrire le code de création d'un tableau **tbl** à deux dimensions organisé en n lignes et n colonnes. L'initialiser à 0."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n = 10\n",
"# A compléter"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 322**\n",
">\n",
">Pour améliorer l'affichage, écrire une fonction **afficherTable(t2d,n)** qui présente le contenu d'un tableau **t2d** à deux dimensions, organisé en n lignes et n colonnes comme dans l'exemple ci-dessous :\n",
">\n",
">*Exemple de résultat attendu* pour **n = 10**\n",
" \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
"\n",
">\n",
"> Tester cette fonction sur le tableau **tbl** de l'exercice précédent."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n",
"def afficheTable(t2d,n):\n",
" pass\n",
"\n",
"\n",
"# test"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 323**\n",
"> Numéroter les cellules du tableau comme dans l'exemple ci-dessous\n",
">\n",
">*Exemple de résultat attendu* pour **n = 10**\n",
" \n",
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] \n",
"[10, 11, 12, 13, 14, 15, 16, 17, 18, 19] \n",
"[20, 21, 22, 23, 24, 25, 26, 27, 28, 29] \n",
"[30, 31, 32, 33, 34, 35, 36, 37, 38, 39] \n",
"[40, 41, 42, 43, 44, 45, 46, 47, 48, 49] \n",
"[50, 51, 52, 53, 54, 55, 56, 57, 58, 59] \n",
"[60, 61, 62, 63, 64, 65, 66, 67, 68, 69] \n",
"[70, 71, 72, 73, 74, 75, 76, 77, 78, 79] \n",
"[80, 81, 82, 83, 84, 85, 86, 87, 88, 89] \n",
"[90, 91, 92, 93, 94, 95, 96, 97, 98, 99] \n",
"\n",
">\n",
"> Tester cette fonction sur le tableau **tbl** de l'exercice précédent."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n",
"\n",
"\n",
"# test"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 324**\n",
">\n",
">Ecrire une fonction **cube**(min,max) qui renvoie la liste des cubes des nombres impairs pour n $\\in$ [min,max].\n",
">\n",
">*Exemple de résultat attendu* \n",
"\n",
"cube(-5,20) => [-125, -27, -1, 1, 27, 125, 343, 729, 1331, 2197, 3375, 4913, 6859] "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n",
"def cube(min,max):\n",
" pass\n",
"\n",
"# test"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 325**\n",
">\n",
">Ecrire une fonction **commun**(a,b) qui renvoie les valeurs communes à deux listes.\n",
">\n",
">*Exemple de résultat attendu* \n",
"\n",
"a = [1,2,3,4,5] b = [2,3,4,6,7] \n",
"commun(a,b) renvoie [2,3,4]\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n",
"def commun(a,b):\n",
" pass\n",
"\n",
"# test"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 Dictionnaires\n",
"**Ressources** : "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**A faire**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.4 Ensembles\n",
"**Ressources** : "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
">**Exercice 341**\n",
">\n",
">Ecrire une fonction **enCommun**(a,b) qui renvoie les valeurs communes à deux listes.\n",
">\n",
">*Exemple de résultat attendu* \n",
"\n",
"a = [1,2,3,4,5] b = [2,3,4,6,7] \n",
"enCommun(a,b) renvoie [2,3,4]\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# A compléter\n",
"def enCommun(a,b):\n",
" pass\n",
"\n",
"# test"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}