1 Algorithme et programme

Programme

Un programme est une séquence d’instructions destinées à être exécutées par la machine.

print("Bonjour")
nom = input("Comment vous appelez-vous?")
print("Bienvenue", nom)

2 Variables

Variable

Les variables sont des noms permettant de désigner des valeurs stockées par le programme.

# type int (integer)
entier = 13
# type float (nombre à virgule flottante)
flottant = 13.0
# type str (string) les chaînes de caractères
texte = "treize"

3 La fonction print(): Afficher une sortie

La fonction print permet au programme d’afficher du texte en sortie.

On peut utiliser plusieurs arguments séparés par des virgules qui seront alors ajoutés les uns à côté des autres (on dit concaténés).

nom = "Sy"
prenom = "Omar"
age = 42
print(prenom, nom, "a", age, "ans.")

Omar Sy a 42 ans.

4 La fonction input(): Récupérer une entrée

La fonction input permet au programme de récupérer du texte en entrée.

Généralement, on récupère le texte entré par l’utilisateur dans un variable en le convertissant dans le type souhaité.

# récupère une chaîne de caractère par défaut
nom = input("Comment vous appelez-vous?")
# on converti la réponse de l'utilisateur en entier avec la fonction int
age = int(input("Quel âge avez-vous?"))
# on converti la réponse de l'utilisateur en fottant avec la fonction float
taille = float(input("Donnez votre taille en mètre"))

1 La logique booléenne

Les booléens sont un type particulier de variables qui n’ont que deux valeurs possibles:

• True: Vrai
• False: Faux

# affectation des variables
a = 7
b = 13
c = 7

# comparaisons
print(a < b) 
print(a == b)
print(a != b)
print(a == c)

True
False
True
True

age = 15

# comparaisons
print(age > 10)  
print(age >= 18) 

# combinaisons
print(age > 10 and age >= 18)  
print(age > 10 or age >= 18)   

True
False
False
True

2 Les instructions conditionnelles

En fonction de conditions on va exécuter des blocs de code différents.

En Python, les blocs sont précédés de : et sont indentés avec 4 espaces.

entrée dans le bloc:
    1ère instruction du bloc
    2e instruction du bloc
    ...
sortie du bloc

if condition:
    instruction 1
    instruction 2
    ...

mdp = input("Entrez votre mot de passe.")
if mdp == "azerty :
    print("Connexion réussie")

if condition:
    bloc d'instructions exécuté si la condition est vraie
else:
    bloc d'instructions exécuté si la condition est fausse

mdp = input("Entrez votre mot de passe.")
if mdp == "azerty :
    print("Connexion réussie")
else:
    print("Mot de passe faux")

if condition 1:
    bloc d'instructions exécuté si la condition 1 est vraie
elif condition 2:
    bloc d'instructions exécuté si la condition 1 est fausse et la condition 2 vraie
else:
    bloc d'instructions exécuté si les conditions 1 et 2 sont fausses

nom = input("Entrez votre nom d'utilisateur.")
mdp = input("Entrez votre mot de passe.")
if nom != "nice06" :
    print("Nom d'utilisateur inconnu")
elif mdp != "azerty":
    print("Mot de passe incorrect")
else:
    # le mot de passe et le nom d'utilisateurs sont corrects
    print("Connexion réussie")

1 Les boucles

Les boucles permettent de répéter des blocs d’instructions.

Il en existe deux types:

• Les boucles bornées avec le mot-clé for.
• Les boucles non bornées avec le mot-clé while.

for i in range(7):
    print(i)

0
1
2
3
4
5
6

mdp = ""                # initialisation
while mdp != "azerty":  # condition d'arrêt de la boucle
    mdp = input("Entrez votre mot de passe.")   # mise à jour de
                                                # la variable de boucle

# On sort de la boucle
print("Vous êtes connecté")

2 Les fonctions

Il s’agit de blocs d’instructions exécutés à la demande, on les définit par le mot-clef def.

# définition de la fonction
def dit_bonjour(prenom):
    print("Bonjour " + prenom)

# appel de la fonction avec l'argument Ada
dit_bonjour("Ada")

Bonjour Ada

def périmètre(rayon):
    p = 2*3.14*rayon
    return p

# on appelle la fonction avec l'argument 0.5
p = périmètre(0.5)
print(p)

3.14

def surface_rectangle(l, L):
    return l*L
# appel
surface_rectangle(2, 3) # renvoie 6

6

import time
def affiche_heure():
    print(time.asctime())

# Pour l'appel on met les parénthèses même s'il n'y a pas d'arguments
affiche_heure()

Wed Jul 31 15:17:09 2024

1 Les formats de données

En informatique les données sont codées sous forme binaire(des 0 et des 1).

La façon de coder l’information dépend du type de fichier que l’on reconnait grâce à son extension.

La plupart des formats ajoutent des données pour décrire le fichier. Ce sont les métadonnées.

2 Qu’est-ce qu’une donnée personnelle ?

Donnée personnelle

Une donnée personnelle correspond à toute information qui permet d’identifier directement ou indirectement une personne physique.

CNIL

3 Descripteurs et valeurs d’un tableau de données

Dans un jeu de données, on distingue:

• le descripteur par exemple artiste qui est un champ commun à tout le jeu de données.
• de sa valeur Adele, Led Zeppelin… qui est propre à chaque ligne des données.

4 Les formats de données structurées

Les données peuvent être stockées sous divers formats adaptés à leurs usages.

opendata.nicecotedazur.org

• Les formats de tableur spécifiques aux logiciels, par exemple:

  • XLS: tableur Microsoft Excel.
  • ODS: tableur LibreOffice sous licence libre.

• Les formats textuels adaptés aux machines et indépendants du logiciel de traitement.

  • CSV: données séparées par des virgules Coma Separated Values

    album,artiste,année,ventes
    Thriller,Michael Jackson,1982,33M
    Led Zeppelin IV,Led Zeppelin,1971,23M
    Legend,Bob Marley & the Wailers,1984,15M
    25,Adele,2015,10M
    

  • JSON: notation objet issue de javascript.

    {"album":"Thriller","artiste":"Michael Jackson","année":1982,"ventes":"33M"}
    {"album":"Led Zeppelin IV","artiste":"Led Zeppelin","année":1971,"ventes":"23M"}
    {"album":"Legend","artiste":"Bob Marley & the Wailers","année":1984,"ventes":"15M"}
    {"album":"25","artiste":"Adele","année":2015,"ventes":"10M"}
    

  • XML: format de données avec balises eXtensible Markup Langage

    <?xml version="1.0" encoding="utf-8"?>
    <data>
      <row>
        <album>Thriller</album>
        <artiste>Michael Jackson</artiste>
        <année>1982</année>
        <ventes>33M</ventes>
      </row>
      <row>
        <album>Led Zeppelin IV</album>
        <artiste>Led Zeppelin</artiste>
        <année>1971</année>
        <ventes>23M</ventes>
      </row>
      <row>
        <album>Legend</album>
        <artiste>Bob Marley &amp; the Wailers</artiste>
        <année>1984</année>
        <ventes>15M</ventes>
      </row>
      <row>
        <album>25</album>
        <artiste>Adele</artiste>
        <année>2015</année>
        <ventes>10M</ventes>
      </row>
    </data>
    

5 Les données ouvertes

À l’inverse des données collectées par certaines entreprises privées pour mieux connaitre leurs utilisateurs ou éventuellement faire un commerce de ces données, les données ouvertes sont librement accessibles grâce à une licence ouverte garantissant leur libre accès et leur réutilisation par tous, sans restriction technique, juridique ou financière.

Données ouvertes

Les données ouvertes ou open data sont des données numériques dont l’accès et l’usage sont laissés libres aux usagers.

6 Informatique en nuage: le cloud

Informatique en nuage

Réseau d’ordinateurs permettant à leurs utilisateurs de partager et utiliser à distance diverses ressources informatiques comme des fichiers, des logiciels, des capacités de calcul et de la mémoire. Wiktionnaire

7 Les dictionnaires en Python

En python, une entrée peut-être représentée par un dictionnaire ou les couples "descripteur": valeur sont séparés par des virgules et entourées d’accolades.

match = {'ligue': 'L1',
         'saison': '2002-2003',
         'jour': '1',
         'date': '2002-08-03 20:00:00+02:00',
         'lieu': 'Nice',
         'equipe_domicile': 'Nice',
         'score_domicile': '1',
         'equipe_exterieur': 'Le Havre',
         'score_exterieur': '2'}

Chaque valeur peut-être accédée grâce à son descripteur (ou clé):

print(match["lieu"]) # affiche "Nice"

8 Exploitation d’un fichier csv en Python

Lorsqu’on lit un fichier csv en Python, chaque ligne du fichier est automatiquement converti en dictionnaire.

Voici par exemple comment afficher toutes les lignes d’un fichier appelé data.csv.

# import du module csv de Python
import csv

# Lecture de chaque ligne sous forme de dictionnaire
with open('data.csv') as csv_file:
    reader = csv.DictReader(csv_file)
    for ligne in reader:
        # affiche le dictionnaire complet
        print(ligne)
        # ou on affiche qu'une valeur par ligne
        # print(ligne["descripteur"])

Voici par exemple la sortie obtenue avec le fichier des musées de Nice:

{"Type d'établissement": 'MUSEE', 'Identité': "MUSÉE D'ART MODERNE ET D'ART CONTEMPORAIN MAMAC", 'Adresse': 'Place Yves Klein 06300 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': 'MUSÉE MATISSE', 'Adresse': '164 Avenue des Arènes de Cimiez, 06000 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': 'PALAIS LASCARIS', 'Adresse': '15 rue Droite            06300 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': "MUSEUM D'HISTOIRE NATURELLE", 'Adresse': '60 bd Risso           06300 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': "MUSEE D'ARCHEOLOGIE DE NICE CIMIEZ", 'Adresse': '160, avenue des Arènes de Cimiez 06000 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': "MUSEE D'ARCHEOLOGIE DE NICE TERRA AMATA", 'Adresse': '25 bd Carnot\n06300 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': 'MUSÉE DES BEAUX-ARTS JULES CHERET', 'Adresse': '33 av des Baumettes    06000 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': "MUSÉE INTERNATIONAL D'ART NAÏF ANATOLE JAKOVSKY", 'Adresse': 'Château Sainte-Hélène 23, avenue de Fabron 06200 NICE'}
{"Type d'établissement": 'MUSEE', 'Identité': 'MUSÉE DE LA PHOTOGRAPHIE CHARLES NEGRE', 'Adresse': '1 Place Pierre Gautier 06300 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': 'VILLA MASSÉNA', 'Adresse': '65 rue de France   06000 Nice'}
{"Type d'établissement": 'MUSEE', 'Identité': 'PRIEURE DU VIEUX LOGIS', 'Adresse': '59 Avenue de Saint-Barthélémy, 06100 Nice'}
{"Type d'établissement": 'GALERIE ', 'Identité': 'GALERIE DE LA MARINE', 'Adresse': '59 quai des Etats-Unis  06300 Nice'}
{"Type d'établissement": 'GALERIE ', 'Identité': 'GALERIE DES PONCHETTES', 'Adresse': '77 Quai des États-Unis, 06300 Nice'}
{"Type d'établissement": '', 'Identité': 'MONASTERE DES FRANCISCAINS', 'Adresse': 'Place du Monastère - 06000 Nice'}

1 L’histoire d’Internet

L’ancêtre d’internet s’appelait ________________. Sur internet, les données sont acheminées sous forme de ________________.

Les règles permettant la transmission des données sont les protocoles:

• TCP qui _________________________________.
• IP qui _________________________________.

2 L’essor d’internet

Internet a fait progressivement disparaître beaucoup des moyens de communication précédents:

• __________________________,
• __________________________,
• __________________________,
• …

Son trafic augmente de façon exponentielle.

3 Les protocoles d’internet

Afin que deux machines puissent communiquer, entre-elles à travers internet, des règles sont définies mondialement: les protocoles.

• Le protocole IP donne une adresse unique à chaque machine du réseau internet.
• Le protocole TCP découpe l’information en paquets avant envoi et les vérifie à la réception puis les réordonne.

Il existe deux versions des adresses IP:

IPv4	IPv6
Une adresse IP (version 4) est constituée de 4 nombres compris entre 0 et 255 séparés par des points.	Les adresses IPv6 sont représentées par huit nombres de quatre chiffres hexadécimaux(de 0 à F, voir) chacun, séparés par deux-points.
Le nombre total d’adresse est $255 \times 255 \times 255 \times 255 = 255^4$ soit environ 4 milliards d’adresse ce qui est largement insuffisant.	Le nombre total d’adresse est $16^{4\times8} \approx 3\times 10^{38}$ qui devrait largement suffire pour longtemps.

ping -6 wikipedia.org
>>>64 octets de text-lb.drmrs.wikimedia.org (2a02:ec80:600:ed1a::1) : icmp_seq=1 ttl=47 temps=30.3 ms

4 Noms de domaine, le protocole DNS

Nom de domaine

Un nom de domaine est un « masque » sur une adresse IP. Le but d’un nom de domaine est de retenir et communiquer facilement l’adresse d’un ensemble de serveurs (site web, courrier électronique, FTP). Article Wikipédia

Le système de nom de domaine est hiérarchique, permettant la définition de sous-domaines.

DNS

Le Domain Name System ou DNS est un service informatique distribué sur Internet qui résout les noms de domaine Internet en adresse IP. Article Wikipedia DNS

5 Communication sur Internet

On distingue deux principaux modes de communication.

Communication client-serveur	Communication pair à pair
Une machine (le client) émet une requête vers une autre machine (le serveur) qui est la seule à pouvoir répondre à ces requêtes.	Dans un réseau pair à pair au contraire, chaque machine est à la fois client et serveur. Les deux machines communiquent directement sans intermédiaire.
La communication client-serveur est la plus utilisée actuellement web, courriel, Vod …	La communication pair à pair est beaucoup moins utilisée actuellement: Torrentpour le partage de fichiers, Skype: Communications audio et vidéos. peertube: partage de vidéos alternative à youtube… Mais beaucoup y voit un avenir prometteur pour décentraliser le web et éviter le recours systématique au serveur des géants du web (GAFAM) qui au passage aspirent des données.

1 L’hypertexte

Les documents hypertextes ont été imaginés en 1965 par Ted Nelson puis mis en pratique dans le Web inventé en 1989 par Tim Berners-Lee.

Lien hypertexte

Un lien hypertexte ou hyperlien permet de passer automatiquement d’un document consulté à un document lié.

2 Le langage html

Les documents du web sont écrits en html(HypertText Markup Langage), le navigateur web traduit le code html et l’affiche à l’utilisateur.

3 Les adresses URL (Uniforme Resource Locator)

Sur le web, chaque page web possède une adresse unique qui permet de l’identifier.

URL

Une URL ou adresse universelle est l’adresse d’une ressource donnée(document, image, vidéo…), unique sur le Web.

Article URL sur MDN

4 Le protocole HTTP

Le protocole HTTP (HyperText Transfer Protocol) gère l’échange de données entre le client et le serveur sur le Web.

• Le client effectue des demandes au serveur comme: - GET: Demande d’une page. - POST: Envoi de données. Pour un formulaire par exemple. - DELETE: Suppression d’une ressource du serveur. - …

Les informations nécessaires à la requête sont placées dans des en-têtes un peu comme si les messages étaient placés dans une enveloppe.

GET /wiki/Hypertext_Transfer_Protocol HTTP/2
Host: fr.wikipedia.org
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0
Accept-Language: fr,fr-FR;q=0.8,en-US;q=0.5,en;q=0.3
Referer: https://www.qwant.com/
Cookie: WMF-Last-Access=14-Sep-2020; WMF-Last-Access-Global=14-Sep-2020; GeoIP=FR:PAC:Nice:43.71:7.26:v4;
...

• Le serveur répond au client en commençant par lui envoyer un code d’état:

   - `200`: succès de la requête
   - ...
   - `301` ou `302`: redirection vers une autre page;
   - `404`: page non trouvée
   - ...
   - `500`: erreur du serveur
   - ...

HTTP/2 200 OK
date: Sun, 13 Sep 2020 09:14:27 GMT
content-language: fr
last-modified: Sun, 06 Sep 2020 18:23:06 GMT
content-type: text/html; charset=UTF-8
content-length: 33988
...

<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8"/>
<title>Hypertext Transfer Protocol — Wikipédia</title>
...
</html>

5 Comment fonctionne un moteur de recherche?

1. Des robots logiciels explorent toutes les pages web: l’exploration.
2. Les pages sont ensuite classées: l’indexation.
3. Lorsque l’utilisateur fait une recherche l’algorithme du moteur de recherche affiche une liste de pages en les classant dans un ordre qui lui est propre: le classement.

6 Les cookies

cookie

Les cookies sont de petits fichiers stockés sur votre navigateur par le serveur pour maintenir votre connexion ou stocker votre panier par exemple.

Les cookies tiers sont des cookies déposés par des serveurs autres que ceux du site que vous visitez. Ces cookies sont souvent utilisés pour vous suivre lors de votre navigation afin d’établir un profil publicitaire ou autre.

7 Les droits sur internet

Le droit d’auteur s’applique sur internet comme ailleurs. Tous les textes, photos, vidéos sont la propriété de leur auteur ou ayant-droits(maison de disques, descendants…) et ce jusqu’à leur entrée dans le domaine public 70 ans après la mort de leur auteur.

Certains sites comme Wikipédia tentent de promouvoir un nouveau type de licence Creative Commons afin que les œuvres puissent être copiées, distribuées, modifiées et adaptées.

1 Le fonctionnement de la géolocalisation

La géolocalisation par satellite nécessite qu’il y en ait toujours au moins quatre satellites « visibles » par le terminal équipé d’une puce de géolocalisation(GPS/Galiléo).

Principe de trilatération

Les coordonnées GPS sont déterminées en mesurant avec une grande précision les distances entre le terminal et trois satellites.

2 Le protocole NMEA

Les informations de géolocalisation peuvent être regroupées au sein d’une trame afin d’être échangées avec d’autres appareils(Maritimes dans le cas de la NMEA).

3 Calculs d’itinéraires et graphes

Pour calculer un itinéraire entre deux villes, on modélise le problème sous forme de graphe.

graphe

Un graphe est une représentation abstraite de liens appelés arêtes entre des objets appelés sommets.

1 Les images numériques

Il existe deux principaux types d’images numériques:

• Les images matricielles dans lesquelles l’image est décrite par une suite de pixels colorées: les formats jpg, png, gif, webp, avif…
• Les images vectorielles dans lesquelles l’image est décrite par les formes contenues dans l’image: le format svg principalement.

2 Définition d’une image

Définition d’une image

La définition d’une image matricielle est le nombre de pixels de l’image.

3 Codage des couleurs

En informatique, il existe différentes façons de coder les couleurs, pour s’en rendre, il suffit d’ouvrir un sélecteur de couleur sur votre ordinateur pour s’en rendre compte.

Système RVB

Un des systèmes les plus courants de codage des couleurs en informatique est le système RVB (pour Rouge Vert Bleu) qui code les intensités des composantes rouge, verte et bleue d’un pixel en synthèse additive des couleurs.

Profondeur des couleurs

La profondeur de couleurs est le nombre de bits utilisés pour représenter la couleur d’un pixel dans une image.

4 Les métadonnées

Métadonnées

En plus des données concernant les couleurs des pixels de l’image, les photographies numériques contiennent de nombreuses informations concernant la prise de vue:

• la date
• l’heure
• l’appareil utilisé pour prendre la photo
• les paramètres de la prise de vue(flash, vitesse…)
• la géolocalisation si disponible

Un des formats de métadonnées couramment utilisé dans les photos est le format EXIF.

1 Identité numérique

Lorsqu’on utilise un réseau social, celui-ci nous demande de créer un compte pour nous identifier.

À chaque interaction avec le réseau, nous devons nous authentifier grâce à un mot de passe par exemple.

Vous obtenez alors une identité numérique qui permet d’associer une personne physique ou morale avec un compte de réseau social.

Lorsque nous sommes identifiés, nous laissons des traces sur le web qui vont façonner notre cyber-réputation.

Cyber-réputation

Réputation d’une entité (personne physique ou morale, marque, produit) en fonction des traces la concernant, trouvables sur le Web.

2 Graphe social

3 Les petits mondes

Sur les réseaux sociaux actuels, 3,5 personnes en moyenne séparent deux personnes choisies au hasard. On est donc effectivement connecté au monde entier.

Cependant, de par la conception des algorithmes de recommandations, ces réseaux nous présentent souvent des contenus de personnes qui nous ressemblent et qui pensent comme nous ce qui « étonnamment » nous empêche d’être au contact des autres et de leurs différences. On reste dans notre petit monde.

1 Interface Homme-Machine

: Interface Homme-Machine (IHM)

Moyens (matériels ou logiciels) prévus pour la communication entre un être humain et une machine.

2 Les objets connectés

Les objets informatisés avaient autrefois des interfaces homme-machine (IHM) dédiées, souvent dépendantes d’une liaison filaire directe. Mais les technologies du Web intégrées au téléphone portable permettent maintenant d’y rassembler les interfaces des objets du quotidien, ce qui en simplifie et uniformise l’usage. Les objets informatisés deviennent ainsi connectés.

On estime à 50 milliards le nombre d’objets connectés en 2020.

1 Comment en est-on arrivé là?

Nous sommes aujourd’hui entourés d’ordinateurs, de serveurs, de tablettes, et nous interagissons avec ces machines quotidiennement, mais comment cela a-t-il été possible?

Comme l’explique l’article Informatique de Wikipédia, cela a été possible grâce à des avancées de nature théorique, mais aussi technologiques.

Ces champs d’application (de l’informatique) peuvent être séparés en deux branches:

• l’une, de nature théorique, qui concerne la définition de concepts et modèles,
• et l’autre, de nature pratique, qui s’intéresse aux techniques concrètes de mise en œuvre.

2 Sources

Les domaines de l’informatique sont nombreux: algorithmique, langages de programmation… Et l’informatique fait intervenir de nombreux domaines connexes: électronique, optique, ondes pour le stockage de données, leur échange sur des réseaux…

Voici quelques liens pour y voir plus clair:

• Une histoire de l’informatique sur le site hypotheses.org
• Histoire de l’informatique de Francois Guillier
• Histoire de l’informatique sur Wikipedia
• Histoire des ordinateurs
• Chronologie de l’informatique

1 Aspects technologiques

1.1 Calculateurs mécaniques

En 1642, Blaise Pascale est le premier à avoir conçu une machine à calculer mécanique, capable d’effectuer les quatre opérations élémentaires sur les entiers: addition, soustraction, multiplication, division.

1.2 Calculateurs électromécaniques

Au début du XX^e siècle, on commence à utiliser l’électricité pour réaliser des calculateurs.

D’abord des machines électromécaniques comme le Z3 allemand achevé en 1941. On le dit électromécanique, car il utilisait des relais électromécaniques fonctionnant à une fréquence de 5 à 10 Hz.(Source Wikipedia)

Zuse Z3 in the Deutsches Museum in Munich, Germany" loading="lazy" decoding="async">

On remplace rapidement les relais électromécaniques par des tubes à vides comme dans l’ENIAC.

1.3 Le transistor et l’avènement de l’électronique

C’est avec l’invention du transistor en 1947 que l’ère de l’électronique et de l’informatique va prendre son envol. Cette découverte vaudra à ses inventeurs américains William Shockley et Walter Brattain le prix Nobel de physique en 1956.

Le transistor est considéré comme un énorme progrès face au tube électronique : beaucoup plus petit, plus léger et plus robuste, fonctionnant avec des tensions faibles, autorisant une alimentation par piles, il fonctionne presque instantanément une fois mis sous tension, contrairement aux tubes électroniques qui demandaient une dizaine de secondes de chauffage, généraient une consommation importante et nécessitaient une source de tension élevée (plusieurs centaines de volts). Wikipedia

2 Aspects théoriques

1 Codage binaire

Le système binaire est un système de numération utilisant la base 2. On nomme couramment bit (de l’anglais binary digit, soit « chiffre binaire ») les chiffres de la numération binaire positionnelle. Ceux-ci ne peuvent prendre que deux valeurs, notées par convention 0 et 1.

C’est un concept essentiel de l’informatique. En effet, les processeurs des ordinateurs actuels sont composés de transistors ne gérant chacun que deux états.

Article Wikipédia sur le système binaire

Actuellement, dans les systèmes numériques comme les ordinateurs, toutes les informations, qu’il s’agisse de nombres, de textes d’images, de sons ou encore de vidéos sont codées sous forme binaire.

Le système binaire est un système de numération positionnel utilisant la base deux.

Les chiffres utilisés sont: 0 1

En plus: Dépassement de capacité

Un dépassement d’entier (integer overflow) est, en informatique, une condition qui se produit lorsqu’une opération mathématique produit une valeur numérique supérieure à celle représentable dans l’espace de stockage disponible. Article Wikipédia

13| 2
   |---
 1 | 6 | 2
       |---
     0 | 3 | 2
           |---
         1 | 1 | 2
               |---
             1 | 0

2 L’octet

Les mémoires actuelles sont toutes composées de cellules mémoires capables de retenir un bit. En mettant pleins de ces cellules dans un seul composant, et en mettant quelques circuits électroniques pour gérer le tout, on obtient une mémoire.OpenClassroom

L’état d’un circuit mémoire, se décrit par une suite finie de 0 et de 1, que l’on appelle un mot. Par exemple, le mot 100 décrit l’état d’un circuit composé de trois circuits mémoires un bit, respectivement dans l’état 1, 0 et 0.

Dans la mémoire des ordinateurs les circuits mémoire un bit sont souvent groupés par huit : les octets.

Octet

Un octet (byte en anglais) est une suite de 8 bits. Il permet de coder $2^8=256$ valeurs.

3 Codage hexadécimal

La notation binaire bien qu’adaptée aux composants électroniques, ne l’est pas du tout pour l’homme. Certains des premiers ordinateurs, comme l’ENIAC utilisaient la base 10, cependant cette idée a été abandonnée en raison des difficultés que cela entraînaient au niveau électronique. La base 16, le système hexadécimal rend l’utilisation du binaire plus humaine.

Un chiffre hexadécimal est un mot de 4 bits puisque $2^4 = 16$.

Les chiffres utilisés sont: 0 1 2 3 4 5 6 7 8 9 a b c d e f

Voici les correspondances entre les bases hexadécimale, décimale et binaire.

En base 2:    101101 = 0010 1101
En base 16:              2    D

 286  | 16
      |---
14(e)| 17 | 16
           |---
         1 | 1 | 16
               |---
             1 | 0 

4 Opérations arithmétiques

Les méthodes utilisées en base dix s’appliquent de la même façon dans les autres bases.

 (1) (1)
    1 0 1 1
  + 1 0 1 0
    -------
  1 0 1 0 1

   (1)
    A 8 0 3
  + 2 D 3 5
    -------
    D 5 3 8

    1 0 1 1
  - 0 1 1 0
   (1)
    -------
    0 1 0 1

     A  8  0  3
  -  2  D  3  5
    (1)(1)(1)
    -----------
     7  A  C  E

5 Conversions et opérations en python

Bien entendu, comme ce genre d’opérations est courante en informatique, python possède des fonctions pour manipuler les nombres entiers en base décimale int(), en base deux bin(), en base seize hex().

Vous pouvez trouver quelques exemples de ces conversions sur cette réponse du forum de programmation en anglais stackoverflow

ATTENTION

Les nombres binaires et hexadécimaux sont représentés en Python sous forme de chaîne de caractères avec un préfixe.

• Ob pour les nombres binaires par exemple'0x1001' pour $1001_{2}$
• Ox pour les nombres hexadécimaux par exemple'0xABCD' pour $ABC_{16}$

1 Méthode naïve: utilisation d’un bit de signe

La façon la plus simple de procéder serait de réserver le bit de poids fort pour le signe(0 pour positif et 1 pour négatif), et de garder le rester pour la représentation de la valeur absolue du nombre.

Avec un codage utilisant des mots de n bits, on pourrait représenter des nombres entre $-2^{n-1}+1$ et $2^{n-1}-1$.

Par exemple, avec un codage sur 3 bits, des nombres entre -3 et 3:

Malheureusement cette représentation possède deux inconvénients. Le premier (mineur) est que le nombre zéro (0) possède deux représentations. L’autre inconvénient (majeur) est que cette représentation impose de modifier l’algorithme d’addition ; si un des nombres est négatif, l’addition binaire usuelle donne un résultat incorrect. Voir l’article de Wikipédia pour plus de détails

2 Notation en complément à deux

Cette méthode permet de remédier aux problèmes évoqués ci-dessus.

On utilise un encodage de longueur fixe $n$:

• La première moitié représente les entiers positifs ou nul codés normalement avec un 0 sur le bit de poids fort;
• La deuxième moitié représente les entiers strictement négatifs. Pour cela on leur ajoute $2^n$ et on retrouve un 1 sur le bit de poids fort.

3 Opérations

   011
  +110
  ----
(1)001

     010
    x110
    ----
     000
    010
   010
   -----
 (01)100

1 Virgule fixe et virgule flottante

Il existe deux façons de coder les nombres à virgule:

• Le codage en virgule fixe qui consiste à garder un nombre fixe de chiffes après la virgule.

• Dans le codage en virgule flottante, on garde un nombre fixe de chiffres significatifs et on réserve l’autre partie du codage à l’exposant. C’est une méthode semblable à la notation scientifique utilisée en physique, mais avec des puissances de 2.

$$\pm m \times 2^{n} \text{ avec } m \in [1; 2[$$

C’est cette deuxième méthode qui est utilisée dans les ordinateurs et smartphones et que nous allons étudier cette année.

2 Principe du codage en virgule flottante

On représente un nombre à virgule flottante sous la forme:

$$s\ m \cdot 2^n$$

Supposons un nombre flottant codé sur un octet utilisant 1 bit de signe, 3 bits pour l’exposant et 4 bits pour la mantisse: 1 100 1011

• $s$ est le signe représenté par le bit de poids fort:

  • $s=0$: signe $+$
  • $s=1$: signe $-$

  $s=1$ Notre codage représente donc un nombre négatif.

• $n$ est l’exposant représenté par un entier relatif décalé et non en complément à deux(ceci afin de faciliter la comparaison des exposants).

  Ce décalage est de $2^{e-1} - 1$ (e représente le nombre de bits utilisé pour coder l’exposant)

  L’exposant a pour valeur 100 codé sur 3 bits, il doit être décalé de $2^{2} - 1 = 3$. Ainsi, puisque $100_2 = 4_{10}$, l’exposant 100 correspond à un exposant de 4-3=1.

• $m$ est la mantisse qui est un nombre binaire à virgule compris entre 1 inclus et 2 exclus. Le seul chiffre avant la virgule étant toujours 1, il n’est pas représenté(on le dit implicite), et le codage binaire de la mantisse représente donc uniquement les chiffres après la virgule qui sont despuissances négatives de 2: de gauche à droite, un demi, un quart, un huitème, un seizième…

Dans notre exemple, la mantisse est: 1011, elle représentera le nombre:

$$m = 1 + \frac{1}{2} + \frac{1}{2^3}+ \frac{1}{2^4} = 1+0,5+0,125+0,0625 = 1,6875$$

Le code 1 101 1011 sur un octet utilisant 1 bit de signe, 3 bits pour l’exposant et 4 bits pour la mantisse représente donc:

$$- 1,6875 \cdot 2^{1}= -3,375$$

Application

Calculer la valeur représentée par le codage suivant sur 16 bits

3 La norme IEEE 754

L’IEEE 754 est une norme pour la représentation des nombres à virgule flottante en binaire. Elle est la norme la plus employée actuellement pour le calcul des nombres à virgule flottante dans le domaine informatique. Source Wikipédia

Cette norme définit notamment 2 formats pour représenter des nombres à virgule flottante:

simple précision (32 bits : 1 bit de signe, 8 bits d’exposant (-126 à 127), 23 bits de mantisse),

double précision (64 bits : 1 bit de signe, 11 bits d’exposant (-1022 à 1023), 52 bits de mantisse).

4 Tests d’égalité sur les flottants

Si on effectue le calcul $0.2 +0.1$ en Python, on obtient:

>>> 0.2 + 0.1
0.30000000000000004

Et contre toute attente, certains tests que l’on aurait cru positifs renvoient des valeurs négatives(ce que l’on appelle un faux négatif):

>>> 0.2 + 0.1 == 0.3
False

Ainsi un calcul avec des nombres à virgule ne peut-être qu’approximatif. Cependant, plus on augmente la taille du registre du processeur et plus nous pourrons représenter de valeurs, et plus nos calculs gagneront en précision.

Comme nous sommes limités sur la précision des flottants, on transforme les tests d’égalités en tests d’inégalités à une précision donnée.

Ainsi:

>>> 0.2 + 0.1 == 0.3
False

Par contre, en utilisant une précision du millionième:

>>> import math # pour utiliser la fonction valeur absolue  fabs()
>>> precision = 1E-6
>>> math.fabs((0.2 + 0.1) - 0.3)  < precision
True

D’ailleurs la bibliothèque math de Python inclut à cet effet la fonction math.isclose().

>>> from math import isclose
>>> isclose(0.2 + 0.1, 0.3)
True

1 Le codage ASCII

Le codage ASCII est une norme de codage de caractères en informatique ancienne et connue pour son influence incontournable sur les codages de caractères qui lui ont succédé. Elle était la plus largement compatible pour ce qui est des caractères latins non accentués. ASCII contient les caractères nécessaires pour écrire en anglais.

L’ASCII définit seulement 128 caractères numérotés de 0 à 127 et codés en binaire de 0000000 à 1111111. Sept bits suffisent donc pour représenter un caractère codé en ASCII. Toutefois, les ordinateurs travaillant presque tous sur un multiple de huit bits (multiple d’un octet) depuis les années 1970, chaque caractère d’un texte en ASCII est souvent stocké dans un octet dont le 8e bit est 0.   Article ASCII sur Wikipédia

Voici la table ASCII:

Certains des caractères présents ne peuvent pas être affichés(repérés par un fond bleu), ce sont des caractères de contrôle. Vous pouvez trouver leur signification sur cette page.

Pour lire le tableau, on associe au caractère le code binaire suivant: n°deligne_n°decolonne. Par exemple, le caractère a est situé dans la case correspondant à la 7ᵉ ligne, 2ᵉ colonne. Sa représentation binaire est:110_0001 soit sous la forme d’un octet: 01100001. Ce qui correspond au caractère 97 en décimal.

Pour faciliter la lecture des codes ASCII par un humain, il est plus commode de coder les numéros de ligne et de colonne en hexadécimal, et la lettre ‘a’ aura alors pour code 61 en hexadécimal.

2 L’encodage ISO

La nécessité de représenter des textes comportant des caractères non présents dans la table ASCII tels ceux de l’alphabet latin utilisés en français comme le ‘à’, le ‘é’ ou le ‘ç’ impose l’utilisation d’un autre codage que l’ASCII.

L’ISO, organisation internationale de normalisation, propose de son côté plusieurs variantes de codages adaptées aux différentes langues. La plus utilisée concerne les langues européennes occidentales. Il s’agit de l’ISO-8859-1, aussi nommé ISO-Latin1. Université de Lille

On peut constater que cette table ne prend pas en charge le caractère €, ainsi une nouvelle norme mieux adaptée au français a été introduite l’ISO 8859-15.

Certains caractères ont été ajoutés dont €, œ, Œ…

Mais il existe d’autres variantes adaptées à d’autres langues:

• ISO-8859-2 pour les pays d’Europe de l’Est,
• ISO-8859-3 pour les pays du sud est de l’Europe…

Du fait de l’internationalisation des pratiques en informatique, on a mis au point un standard international permettant d’encoder les caractères de toutes les langues: le standard Unicode.

3 L’encodage Unicode UTF-8

L’encodage UTF-8 est un encodage en élaboration qui permet d’encoder tous les caractères de toutes les langues, il est actuellement en train de s’imposer face aux antres encodages en raison de son universalité.

À l’évidence, 256 caractères ne suffisant pas pour représenter les lettres de tous les alphabets utilisés (pensons au russe, à l’hébreu, etc.), un nouveau standard a été introduit : Unicode. La table Unicode comporte la définition de près de cent cinquante mille caractères.   Le codage de cette table est multiple. Le codage le plus couramment utilisé se nomme UTF-8. Son principe est le suivant : une première série de caractères sont codés sur un octet. D’autres caractères sont codés sur deux octets, le premier octet débute par ‘110’ pour l’indiquer, l’octet suivant débute par ‘10’. De même des codages sur 3 ou 4 octets sont utilisés pour d’autres caractères. (Cette rapide introduction à UTF-8 est volontairement simplifiée.)   Les 128 premiers caractères de la table UTF-8 sont compatibles avec le codage ASCII. Ainsi le codage UTF-8 d’un texte ne comportant que des caractères présents dans la table ASCII sera le même que le codage ASCII de ce texte.   Ce ne sera pas vrai pour un texte ISO-Latin-1. Il importe donc, quand on veut décoder un texte, de savoir quel est le codage utilisé sous peine de décoder improprement les caractères. Université de Lille

La table complète des caractères Unicode peut être consultée sur l’article Wikipédia

Par exemple si on cherche dans cette table la lettre é, on trouve le code:U+00E9 appelé point code, en binaire cela correspond au nombre décimal 233, et au nombre binaire 1110 1001. Ce nombre binaire sera représenté en UTF-8 sur deux octets sous la forme: 110x_xxxx 10xx_xxxx. Les chiffres binaires du point de code sont rangés de droite à gauche aux positions ‘x’ de ce schéma.

On obtient donc 1100_0011 1010_1001 pour le caractère é.

Ce qui représente en hexadécimal:C3 A9, il occupe donc deux octets.

4 L’encodage des caractères en python

En python 3, tous les fichiers doivent être codés en UTF-8, et les chaînes de caractères string sont encodées en UTF-8, contrairement aux bytes qui ne doivent contenir que des caractères ASCII.

5 L’encodage des caractères en html

Pour obtenir un affichage correct des caractères spéciaux en html, il faut déclarer l’encodage utf-8 dans le fichier d’en-tête(<head>) de la page html en utilisant la balise <meta>.

Voici la structure type d’un fichier html5.

<!doctype html>
<html>

    <head>
        <meta charset="utf-8">
        <title>Titre du document</title>
    </head>

    <body>
        Contenu du document, avec d'éventuels accents!!!
        et caractères étranges , de toutes les langues...
        ...ظɶ
        ...ऴ,ඛ
        ...ტ,ላ,Ꮹ,ᜨ...
    </body>
</html>

Il est également possible d’afficher des caractères par leur code html, ces codes sont également présents sur l’article Wikipédia.

Par exemple le caractère À U+00C0 peut être codé en html par À, ou encore en notation hexadécimale: À

1 Introduction à l’algèbre de Boole

Dans le monde noir et blanc des idéaux, il y a une vérité absolue. C’est-à-dire que tout est vrai ou faux. Dans ce contexte philosophique, considérons les exemples suivants:

“Un plus un égal deux.” Vrai ou faux?

C’est (sans doute) vrai!

“1 + 1 = 2” ET “2 + 2 = 4” Vrai ou faux?

C’est aussi vrai.

Mais qu’en est-il:

“1 + 1 = 3” OU “Sydney est en Australie” Vrai ou faux?

C’est vrai! Bien que 1 + 1 = 3 ne soit pas vrai, le OU dans l’instruction a indiqué que, si l’une ou l’autre partie de l’instruction est vraie, l’instruction entière l’est également.

Considérons maintenant un exemple plus déconcertant

“2 + 2 = 4” OU “1 + 1 = 3” ET “1 - 3 = -1” Vrai ou faux?

La vérité ou la fausseté des déclarations dépend de l’ordre dans lequel vous évaluez la déclaration. Si vous évaluez d’abord “2 + 2 = 4 OU 1 + 1 = 3”, la déclaration est fausse et sinon vraie. Comme en algèbre ordinaire, il est nécessaire de définir certaines règles pour régir l’ordre d’évaluation, afin d’éviter toute ambiguïté.

Avant de décider dans quel ordre évaluer les énoncés, nous faisons ce que la plupart des mathématiciens aiment faire, remplacer les phrases par des symboles ces symboles représentent ce que l’on appelle des variables propositionnelles:

• Soit $P$ la vérité ou la fausseté de l’énoncé 2 + 2 = 4.
• Soit $Q$ la vérité ou la fausseté de l’énoncé 1 + 1 = 3.
• Soit $R$ la vérité ou la fausseté de l’énoncé 1 - 3 = -1.

Ensuite, l’exemple ci-dessus peut être récrit de manière plus compacte:

$$P\ \textrm{ou}\ Q\ \textrm{et}\ R$$

Pour aller encore plus loin, les mathématiciens remplacent également les opérations par des signes OU par $\vee$ et ET par $\wedge$, l’énoncé devient:

$$P \vee Q \wedge R$$

Il faut également établir l’ordre de priorité. Nous évaluons ET en premier, puis OU avec le P.

La déclaration $P \vee Q \wedge R$ est vraie on peut écrire:

$$P \vee Q \wedge R = \textrm{VRAI}$$

2 Opérations fondamentales et notations

Dans ce cours on notera les valeurs $\textrm{VRAI} = 1$ et $\textrm{FAUX} = 0$.

L’algèbre booléenne est construite à partir de 3 opérations fondamentales, les notations dépendent du domaine d’étude (logique, électronique, algèbre…), on utilisera une notation proche de langages de programmation usuels tels que le C ou le javascript.

On notera dans ce cours les variables booléennes avec des lettres majuscules: $\displaystyle P$, $\displaystyle Q$, $\displaystyle R$… On parle de variable propositionnelle.

Dans les langages informatiques, les syntaxes peuvent être encore différentes!

3 Tables de vérités

Tables de vérité

Une table de vérité donne tous les résultats possibles d’une opération booléenne en fonction de la ou les entrées.

Nous allons dans un premier temps nous intéresser aux tables de vérité des trois fonctions logiques fondamentales:

P   Q   R
---------
0   0   0
0   0   1
0   1   0
0   1   1
1   0   0
1   0   1
1   1   0
1   1   1

P   Q   R  | P & Q | R
-----------|----------
0   0   0  |     0
0   0   1  |     1
0   1   0  |     0
0   1   1  |     1
1   0   0  |     0
1   0   1  |     1
1   1   0  |     1
1   1   1  |     1

4 Équivalence d’expressions booléennes

En algèbre ordinaire, deux expressions peuvent être équivalentes, par exemple:

$$x \times z + y \times z = (x + y) \times z$$

La même chose peut être dite de l’algèbre booléenne. Construisons des tables de vérité pour:

$P \& R | Q \& R$ et $(P | Q) \& R$

P   Q   R  | P & R | Q & R
--------------------------
0   0   0  |       0 
0   0   1  |       0 
0   1   0  |       0 
0   1   1  |       1 
1   0   0  |       0 
1   0   1  |       1 
1   1   0  |       0 
1   1   1  |       1 

P   Q   R  | (P | Q) & R
------------------------
0   0   0  |     0 
0   0   1  |     0 
0   1   0  |     0 
0   1   1  |     1 
1   0   0  |     0 
1   0   1  |     1 
1   1   0  |     0 
1   1   1  |     1 

En comparant les deux tableaux, vous aurez remarqué que les résultats(c’est-à-dire la dernière colonne) des deux tableaux sont identiques!

Équivalence d’expressions booléennes

Nous disons que deux expressions booléennes sont équivalentes si la sortie de leurs tables de vérité est la même. L’équivalence d’expressions booléennes est notée avec le signe =.

5 Les lois de l’algèbre de BOOLE

Il n’est pas demandé d’apprendre ces lois, mais vous devez savoir les démontrer.

Ces lois peuvent facilement être démontrées à l’aide de tables de vérité.

1 Qu’est-ce qu’un tableau?

Tableau

En informatique, un tableau est une structure de données représentant une séquence finie d’éléments auxquels on peut accéder efficacement par leur indice, dans la séquence.

Il existe deux implémentations des tableaux en Python: les tuples et les listes.

t = (1, 2, 3)
type(t)

tuple

# sans parenthèses
t = 1, 2, 3
type(t)

tuple

tab = [ "a", "z" , "e"]
type(tab)

list

2 Différences et similitudes entre tuple et listes

t = (1, 2.0, "trois")
t
type(t)
t[0]
t[1]
t[2]
len(t)
t[0] = "un"
tab = [1, 2.0, "trois"]
tab
type(tab)
tab[0]
tab[1]
tab[2]
len(tab)
tab[0] = "un"
tab

(1, 2.0, 'trois')

tuple

1

2.0

'trois'

3

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[10], line 1
----> 1 t[0] = "un"

TypeError: 'tuple' object does not support item assignment

[1, 2.0, 'trois']

list

1

2.0

'trois'

3

['un', 2.0, 'trois']

ATTENTION: Dans les types construits, il faut bien distinguer l’indice et la valeur stockée à cet indice.

3 Méthodes et fonctions

# appel d'une fonction
fonction(arguments) # ex: len(tab)
# appel d'une méthode d'objet
objet.méthode(arguments) # ex: tab.append(5)

t = (1, 1, 1, 2, 2)

# appel de la méthode index()
t.index(2)

3

t.count(1)

3

help(tuple)

Help on class tuple in module builtins:

class tuple(object)
 |  tuple(iterable=(), /)
 |
 |  Built-in immutable sequence.
 |
 |  If no argument is given, the constructor returns an empty tuple.
 |  If iterable is specified the tuple is initialized from iterable's items.
 |
 |  If the argument is a tuple, the return value is the same object.
 |
 |  Built-in subclasses:
 |      asyncgen_hooks
 |      UnraisableHookArgs
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.

# ajout à la fin
tab.append(4)
tab

['un', 2.0, 'trois', 4]

# ajout à l'indice 0(au début)
tab.insert(0, 'zéro')
tab

['zéro', 'un', 2.0, 'trois', 4]

tab.pop()
tab

['zéro', 'un', 2.0, 'trois']

tab.pop(1)
tab

['zéro', 2.0, 'trois']

help(list)

Help on class list in module builtins:

class list(object)
 |  list(iterable=(), /)
 |
 |  Built-in mutable sequence.
 |
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, index, /)
 |      Return self[index].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the list.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |
 |  __sizeof__(self, /)
 |      Return the size of the list in memory, in bytes.
 |
 |  append(self, object, /)
 |      Append object to the end of the list.
 |
 |  clear(self, /)
 |      Remove all items from list.
 |
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
 |
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  insert(self, index, object, /)
 |      Insert object before index.
 |
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
 |
 |      Raises IndexError if list is empty or index is out of range.
 |
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |
 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |
 |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
 |      order of two equal elements is maintained).
 |
 |      If a key function is given, apply it once to each list item and sort them,
 |      ascending or descending, according to their function values.
 |
 |      The reverse flag can be set to sort in descending order.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

4 Utilisations courantes des tuples

t = ("α", "β", "γ")
a, b, c = t
print("t=", t)
print("a=", a)
print("b=", b)
print("c=", c)

t= ('α', 'β', 'γ')
a= α
b= β
c= γ

a = 3
b = 2
print("a=",a, "b=", b)
print("Permutation")
a, b = b, a
print("a=",a, "b=", b)

a= 3 b= 2
Permutation
a= 2 b= 3

def racines_du_trinome(a,b,c):
    delta = b**2-4*a*c
    if delta >= 0:
        return -b-delta**0.5/(2*a), -b+delta**0.5/(2*a)

racines_du_trinome(1,0,-1)

(-1.0, 1.0)

x1, x2 = racines_du_trinome(1,0,-2)
print("racine 1:", x1)
print("racine 2:", x2)

racine 1: -1.4142135623730951
racine 2: 1.4142135623730951

5 Savoir si un tableau contient une valeur

Outre la méthode index(), on peut utiliser l’opérateur booléen in pur savoir si une valeur est dans la liste.

tab = [1, 3, 5]
print(3 in tab)
print(4 in tab)

True
False

6 Parcours séquentiel des tableaux

Les tableaux étant des structures ordonnées finies, il est facile de les parcourir dans l’ordre avec une boucle bornée for.

En python, on peut réaliser l’itération sur les valeurs ou sur les indices si nécessaire. Cette dernière est plus compliquée, mais plus puissant, car on a alors accès à l’indice i et à la valeur tab[i]).

tab = [12, -3, 15, -9, 17, 7]
for val in tab:
    print(val)

12
-3
15
-9
17
7

t = (12, -3, 15, -9, 17, 7)
for i in range(len(t)):
    val = t[i]
    print("indice:", i, "valeur:", val)

indice: 0 valeur: 12
indice: 1 valeur: -3
indice: 2 valeur: 15
indice: 3 valeur: -9
indice: 4 valeur: 17
indice: 5 valeur: 7

for lettre in "Bonjour":
    print(lettre)

B
o
n
j
o
u
r

mot = "Bonjour"
for i in range(len(mot)):
    val = mot[i]
    print("indice:", i, "valeur:", val)

indice: 0 valeur: B
indice: 1 valeur: o
indice: 2 valeur: n
indice: 3 valeur: j
indice: 4 valeur: o
indice: 5 valeur: u
indice: 6 valeur: r

1 Tableau donné en compréhension

Plutôt que de remplir un tableau par énumération de ces éléments dans une boucle, on peut définir des listes en compréhension, c’est-à-dire des listes dont le contenu est défini par filtrage du contenu d’une autre liste.

t = []
for i in range(13):
    t.append(2**i)
t

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]

t = [2**n for n in range(13)]
t

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]

t = [2**n for n in range(13) if n % 2 == 0]
t

[1, 4, 16, 64, 256, 1024, 4096]

[f(x) if condition else g(x) for x in sequence]

[str(i) + " est pair" if i % 2 == 0 else str(i) + " est impair" for i in range(5)]

2 Tableaux à deux dimensions: les matrices

Pour représenter un tableau de données, on peut utiliser une liste de liste. $$\begin{pmatrix} 1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9 \end{pmatrix}$$

mat = [[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]]
mat

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

mat[0][2]

3

mat[2][1]

8

mat[1]

[4, 5, 6]

[ligne[0] for ligne in mat]

[1, 4, 7]

for ligne in mat:
    for val in ligne:
        print(val)

1
2
3
4
5
6
7
8
9

1 Syntaxe

Les dictionnaires sont entourés d’accolades {}. Les clés doivent être des objets imuables, typiquement des str.

{'clé_1': valeur_1, 'clé_n': valeur_n, ...'clé_n': valeur_n}

D = { 'nom': 'Lagaffe' , 'prenom': 'Gaston', 'age': 22 }
type(D)

dict

Pour accéder aux éléments du dictionnaire, il suffit d’appeler la clé correspondante, d’autre part la fonction len() est également disponible.

len(D)

3

D['nom']

'Lagaffe'

D['age']

22

2 Ajout et suppression d’éléments

Les dictionnaires étant mutables, on peut ajouter des éléments au dictionnaire en **assignant* des clés paire valeur à notre guise.

D["expression"] = "M'enfin"
D

{'nom': 'Lagaffe', 'prenom': 'Gaston', 'age': 22, 'expression': "M'enfin"}

On peut au contraire supprimer des éléments du dictionnaire avec la méthode pop().

D.pop("age")
D

{'nom': 'Lagaffe', 'prenom': 'Gaston', 'expression': "M'enfin"}

3 Autres méthodes des dictionnaires

Les méthodes des dictionnaires sont décrites dans la documentation ou grâce à l’appel help(tuple), outre les méthodes d’itération il peut être utile de connaitre la méthode get(clé) qui renvoie la valeur associée à l clé ou None si la clé n’existe pas.

Cela permet d’éviter les exceptions du type KeyError si la clé n’existe pas.

D

{'nom': 'Lagaffe', 'prenom': 'Gaston', 'expression': "M'enfin"}

Par exemple, la clé age n’existe plus donc la syntaxe d’accés par clé renvoir une erreur.

print(D["nom"])
print(D["prenom"])
print(D["age"])

Lagaffe
Gaston

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[8], line 3
      1 print(D["nom"])
      2 print(D["prenom"])
----> 3 print(D["age"])

KeyError: 'age'

Par contre, la méthode get() ne générera pas la KeyError et renverra None la clé n’existe pas.

print(D.get("nom"))
print(D.get("prenom"))
print(D.get("age"))

Lagaffe
Gaston
None

help(dict)

Help on class dict in module builtins:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |
 |  Built-in subclasses:
 |      StgDict
 |
 |  Methods defined here:
 |
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, else False.
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __ior__(self, value, /)
 |      Return self|=value.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |
 |      If the key is not found, return the default if given; otherwise,
 |      raise a KeyError.
 |
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  fromkeys(iterable, value=None, /)
 |      Create a new dictionary with keys from iterable and values set to value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None

4 Itération sur les dictionnaires

Les dictionnaires étant des associations de clés(keys) et de valeurs(values), il existe trois méthodes pour itérer sur les clés, les valeurs ou les deux.

for key in D.keys():
    print(key)