{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Opérations sur les bits en Python - Sujet" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ressources** : " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "**Sommaire**\n", "
    \n", "
  1. Présentation
    2. \n", "
      \n", "
    1. Opération bit à bit
      2. \n", "
    2. Architecture matérielle : UAL
      3. \n", "
    3. Opérations bit à bit en Python
      4. \n", "
    \n", "
  2. Travail demandé\n", "
      \n", "
    1. Algorithmique
      2. \n", "
    2. Codage
      3. \n", "
    \n", "
    3. \n", "
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Présentation\n", "**Source** : Wikipédia\n", "\n", "### 1A. Opérations bit à bit\n", "En logique, une opération **bit à bit** est un calcul manipulant les données directement au niveau des bits, selon une arithmétique booléenne. Elles sont utiles dès qu'il s'agit de manipuler les données à bas niveau : codages, couches basses du réseau (par exemple TCP/IP), cryptographie.\n", "\n", "#### Opérateurs\n", "Les opérateurs élémentaires sont des opérations binaires réalisées simultanément sur l'ensemble des bits d'un mot de manière indépendante. Ainsi, la valeur du bit de rang n dans le résultat ne dépend que des valeurs des bits de même rang dans les opérandes d'entrée.\n", "\n", "##### NON bit à bit\n", "

Chaque bit est inversé.


\n", "Exemple
\n", "S = NON 01112 = 10002 (sur 4 bits, NON 710 = 810)\n", "\n", "\n", "##### ET bit à bit de deux expressions\n", "\n", "\n", "Exemple
\n", "N1 = 010011002 = 7610, N2 = 000011002 = 1210
\n", "S = N1 ET N2 = 000011002 (sur 8 bits, 7610 ET 1210 = 1210)\n", "\n", "\n", "##### OU bit à bit de deux expressions\n", "\n", "Exemple
\n", "N1 = 000010002 = 810, N2 = 010101012 = 8510
\n", "S = N1 OU N2 = 010111012 (sur 8 bits, 810 OU 8510 = 9310)\n", "\n", "\n", "##### OU EXCLUSIF bit à bit de deux expressions\n", "\n", "Exemple
\n", "N1 = 110010012 = 20110, N2 = 000011112 = 1510
\n", "S = N1 OU EXCLUSIF N2 = 110001102 (sur 8 bits, 20110 OU EXCLUSIF 1510 = 19810)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Les opérations ci-dessus peuvent être vérifiées avec la calculatrice Windows en mode programmeur.

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.B Architecture matérielle : UAL\n", "\n", "#### Unité arithmétique et logique\n", "L'unité arithmétique et logique (**UAL**, en anglais arithmetic–logic unit, ALU), est l'organe de l'ordinateur chargé d'effectuer les calculs. Le plus souvent, l'UAL est incluse dans l'unité centrale de traitement ou le microprocesseur.\n", "\n", "Les UAL effectuent des **opérations** :\n", "\n", "\n", "

Exemple d'architecture matérielle : von Neumann

\n", "\n", "\n", "\n", "#### Logigramme d'un ET bit à bit\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.C Opérations bit à bit en Python\n", "Python dispose d'opérateurs bit-à-bit (bitwise) qui agissent directement sur les nombres au niveau des bits. \n", "\n", "Ces opérateurs sont au nombre de six :
\n", "\n", "'&': ET.
\n", "'|': OU.
\n", "'^': OU EXCLUSIF.
\n", "'~': INVERSION des bits du nombre situé à droite.
\n", "'»': DECALAGE d'un bit à DROITE (correspond à une division par 2)
\n", "'«': DECALAGE d'un bit à GAUCHE (correspond à une multiplication par 2)
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Exemple à tester\n", "7&6" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### La fonction native bin()\n", "La fonction native (built-in) **bin** convertit un nombre entier en binaire dans une chaîne avec le préfixe 0b. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Exemples à tester\n", "print(\"bin(6) = \", bin(6))\n", "#0b identifie la valeur qui suit comme étant un nombre binaire\n", "print(\"bin(5 & 12) = bin(0b0101 & 0b1100)\",bin(0b0101 & 0b1100))" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-09e20b8b31c8d12d", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "\n", " \n", " \n", " \n", " \n", "

Comme on le voit ci-dessus, Python n'affiche les bits d'un nombre binaire qu'à partir du premier bit non nul !!!

" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-9eb2e175d10f3383", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "## 2. Travail demandé\n", "**Source**: Numérique et sciences informatiques 1er- Ellipses \n", "\n", "#### Enoncé\n", "> **Ecrire** un programme Python qui affiche la table d'une des opérations logiques (ET, OU, OU-EXCLUSIF) pour tous les entiers de n bits.
\n", "\n", "#### Exemple de résultat attendu\n", "Pour l'opération **ET bit à bit** et **n = 2**, le programme doit afficher :\n", "\n", "\n", "\n", "#### Etapes à suivre\n", "- Ecrire un algorithme (§2.A)\n", "- Coder le programme en Python (§2.B)\n", "\n", "Remarque : on se limitera à n = 3 dans les tests.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.A Algorithmique" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-c4bdef455c1a3fc2", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "> **Activité 1**\n", ">\n", "> **Proposez** un algorithme affichant uniquement les résultats d'une table ET pour n = 2 (**valeurs en gras** dans la table ci-dessus)." ] }, { "cell_type": "raw", "metadata": {}, "source": [ "Algorithme TablesLogique\n", "var\n", "à compléter\n", "\n", "\n", "début\n", "à compléter\n", "fin" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-32041b1790a99aa9", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "### 2.B Codage\n", "On demande **quatre versions** du programme. Celles-ci sont décrites dans les **activités 2 à 5** ci-dessous." ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-42855d71237c42a0", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "> **Activité 2** \n", ">\n", "> La **version 1** doit uniquement afficher les résultats de l'opération **ET** avec **n=2**.\n", ">\n", "> Ressource : Les chaînes de caractères.\n", ">\n", ">Résultat attendu\n", ">\n", ">['0b0', '0b0', '0b0', '0b0']\n", ">\n", ">['0b0', '0b1', '0b0', '0b1']\n", ">\n", ">['0b0', '0b0', '0b10', '0b10']\n", ">\n", ">['0b0', '0b1', '0b10', '0b11']" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Version 1\n", "# A compléter" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-1cf6159e23d24b32", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "> **Activité 3** \n", ">\n", ">Dans la **version 2** (à coder en reprenant la version 1), les nombres s'affichent avec **n** chiffres (opération **ET**, **n=2**)\n", ">\n", ">Ressources : La méthode String zfill() et Les chaînes de caractères.\n", ">\n", ">Résultat attendu\n", ">\n", ">['00', '00', '00', '00']\n", ">\n", ">['00', '01', '00', '01']\n", ">\n", ">['00', '00', '10', '10']\n", ">\n", ">['00', '01', '10', '11']" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Version 2 \n", "# A compléter" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-a476ed80b37564a7", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "> **Activité 4** \n", ">\n", "> Dans sa **version 3** (à coder en reprenant la version 2), le programme affiche une table **ET** de **3 bits** et présente les valeurs à traiter sur la première ligne et la première colonne de la table. \n", ">\n", ">Résultat attendu (partiel) pour n=3\n", ">\n", ">['___', '000', '001', '010', '011', '100', '101', '110', '111']\n", ">\n", ">['000', '000', '000', '000', '000', '000', '000', '000', '000']\n", ">\n", ">['001', '000', '001', '000', '001', '000', '001', '000', '001']\n", ">\n", ">['010', '000', '000', '010', '010', '000', '000', '010', '010']\n", ">\n", ">etc." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Version 3\n", "# A compléter" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-e4d59ae5f2168269", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "> **Activité 5** \n", ">\n", ">Dans sa **version 4** (à coder en reprenant la version 3), le programme traite les opérations **ET**, **OU** et **OU-EXCLUSIF**. Le choix de l'opération se fait à l'aide d'une variable _operation_.\n", ">\n", ">Résultat attendu (partiel) pour n=3, l'opération est un OU-EXCLUSIF\n", ">\n", ">OU-EXCLUSIF bit-à-bit\n", ">\n", ">['___', '000', '001', '010', '011', '100', '101', '110', '111']\n", ">\n", ">['000', '000', '001', '010', '011', '100', '101', '110', '111']\n", ">\n", ">['001', '001', '000', '011', '010', '101', '100', '111', '110']\n", ">\n", ">etc." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Version 4\n", "\n", "operation=2 # opération à traiter (0->&, 1->|, 2->^)\n", "\n", "# A compléter" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "celltoolbar": "Create Assignment", "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10.5" } }, "nbformat": 4, "nbformat_minor": 4 }