Leçons
Voici ce que nous travaillons durant cette année de spécialité NSI en Première.
Chapitre 1 : Représentation des nombres
Introduction
1800 ans av J-C les Babyloniens comptaient en base 60, donc, avec une numération de position. Au IVème s, les Indous inventent le 0. Pour finir, au XVIIème s, Leibnitz créé une machine numérique à calculer en base binaire.
1) Conversions de base
Aujourd'hui, les 3 bases étudiées sont la base décimale, 10, base de tous les jours, la base binaire, 2, ainsi que la base hexadécimale, 16 (voir l'image ci-contre).
Pour convertir de la base binaire en base décimale, il faut utiliser la numérotation de position. Par exemple, pour le nombre en base binaire 1011001, il faut convertir comme ceci :
1011001 = 1*2^6+0*2^5+1*2^4+1*2^3+0*2^2+0*2^1+1*2^0 = 1*2^6+1*2^4+1*2^3+1*2^0
= 64+16+8+1
= 89 en base décimale
De même, pour convertir un nombre de base hexadécimale en base décimale, il faut utiliser cette numérotation de position. Pour convertir le nombre en base hexadécimale 12A, il faut faire :
12A = 1*16^2+2*16^1+10*16^0
= 256+32+10
= 298 en base décimale
À l'inverse pour convertir un nombre de base décimale en base binaire ou hexadécimale, il faut utiliser la division euclidienne. Pour convertir 89 en base binaire, il faut utiliser comme dividende 89 et comme diviseur 2. Il faut diviser par 2 jusqu'à que le quotient soit égal à 0.
89 |2
-88 | 44 |2
1 |- 44 | 22 |2
| 0 |- 22 | 11 |2
| 0 | -10 | 5 |2
| 1 |-4 | 2 |2
| 1|-2 | 1 |2
| 0 | -0 |0
| 1
Pour lire le résultat, il faut lire de droite à gauche les différents restes. 89 (base 10), est donc égal à 101 1001(base 2)
De même, pour convertir 89 en base hexadécimale, il faut utiliser comme dividende 89 et comme diviseur 2. Il faut donc diviser par 16 jusqu'à que le quotient soit égal à 0.
89 |16
-80 | 5 |16
9 |- 0 |0
| 5
De même, il faut lire les restes de droite à gauche : 89 (base 10) est égal à 59 (base 16).
2) Additions et multiplications
3) Codage des entiers négatifs et nombres flottants
On code un entier par la méthode du complément à 2.
On écrit d'abord le nombre positif correspondant : 8 (base 10) = 1000 (base 2). On prend le complément à 1 de ce nombre (on inverse chaque bit) : 1000 --> 0111. On rajoute 1 :
111
0111
+0001
1000
-8 a donc le même codage que 8 car lorsqu'on code sur 4 bits, il y a 2^4 = 16 possibilités donc [-8;7].
Le complément à 2 est la principale méthode de codage des nombres négatifs car elle n'a qu'un seul zéro. Chaque langage peut utiliser plusieurs méthodes pour coder les nombres négatifs.
Le codage des nombres à virgules flottantes donne un résultat approximatif en Python. Pour convertir un nombre à virgules flottantes en base binaire, on convertit d'abord la partie entière puis la partie décimale. Pour cela, on la multiplie par 2 et on conserve la partie entière de cette multiplication. On s'arrête quand la partie décimale est nulle. On marque alors la partie entière, puis la virgule et pour finir la partie décimale : il faut lire les parties entières du début jusqu'à la fin. Par exemple, pour 5,125 :
Partie entière : 5 (base décimale) = 101 (base binaire)
Partie décimale : 0,125 :
Partie entière | Partie décimale
0,125*2=0,250 0 | 0,250
0,250*2=0,5 0 | 0,5
0,5*2=1 1 | 0
5,125 (base 10)=101,001 (base 2)
Addition :
111
010011001
+100101010
111000011
Lors d'une somme de 2 entiers à nbits on a au maximum besoin de n+1 bit pour le résultat. L'overflow est le dépassement de capacité lors d'une opération. Le bit de poids le plus fort est manquant.
/ 6 bits \
1111
100111
+111100
1100011
\ 7 bits /
110
x 11
11110
1100
10010
Il faut 2 nbit pour le résultat pour une multiplication au maximum si les nombres sont codés sur nbit.
Chapitre 2 : Porte logique et représentation d'un texte en machine
1) Porte logique
Les fonctions logiques (ou porte logique ou fonction booléenne) prennent comme paramètre d'entrée, "True" ou "False", "1" ou "0".
a=3 --> affectation de la valeur 3 dans la variable a
a==3 comparaison de a et de 3 --> True or False --> True
La comparaison renvoie donc une grandeur booléenne.
b=true --> affectation de la valeur "true" à la variable booléenne b
Les portes logiques sont composées de plusieurs transistors et sont utilisées dans tous les systèmes électroniques.
Voir ci-dessous les TABLES DE VÉRITÉ
if a==3 :
print ...
else ...
Avec 4 espaces appelés l'indentation.
En programmation Python, ces fonctions booléennes sont utilisables dans l'écriture d'une condition.
def fonction_1 (x;y) :
if x==0 or y==0 :
return None
else :
return 1/(x*y)
a=fonction_1 (0;2)
print(a)
Vocabulaire :
def : mot clé pour définir une fonction
fonction_1 : nom de la fonction définie par l'utilisateur
x;y : paramètres de la fonction/argument
Ici, la condition est vraie si (if) x=0 (x==0) ou y=0 (y==0) ou les deux.
Si la fonction est vraie, la fonction ne renvoie rien (return None) pour éviter une erreur de calcul.
else : Si la condition précédente n'est pas vérifiée, alors on calcule 1/x*y (1/(x*y)).
Ces lignes ne s'exécuteront jamais sauf si la fonction est appelée : a=fonction_1 (0;2)
Pour connaître le résultat l'utilisateur peut dire print(a).
L'additionneur 1 bit utilise des portes booléennes pour additionner en tenant compte des retenues : Entrée 1 (1,0), Entrée 2 (1,0) et Retenue (1,0) sont les 3 entrées alors que Somme et Retenue sont les 2 sorties.
2) Le codage des textes
Le codage des caractères a débuté dans les années 60 avec le code ASCII. Sur 1 octet, seuls 7 bits étaient utilisés pour coder 118 caractères non accentués.
Le codage a été étendu aux caractères accentués avec LATIN-1 et puis à tous les caractères avec l'Unicode.
L'UTF-8 est la version d'Unicode utilisée par 95% des sites web actuels. Son intérêt est qu'il utilise 1 à 4 octet pour coder chaque caractère. Les caractères les moins fréquents étant codés sur plus d'octet que les caractères fréquents.
Chapitre 3 : Types construits
En Python, il n'est pas utile de déclarer le type des variables.
a=3 --> variable entière
b=1.66 --> variable à virgules flottantes
c=False --> variable booléenne
Les types construits sont des structures de variable rassemblant des valeurs sous un même nom.
1 ) Les Tuple ou n-uplet
L'éditeur Python Bordas en ligne est constitué de 2 parties. À gauche, un écran permettant d'écrire et d'enregistrer un ensemble de lignes de coder avant de les exécuter. À droite, une console dans laquelle chaque ligne s'exécute au moment où elle est écrite :
>>> t1=(1,2,3,5,6,)
>>>t1
(1, 2, 3, 4, 5, 6)
Création d'un tuple nommé t1.
>>>t1=1,
>>>t1
(1,)
Déclaration d'un tuple sans parenthèses.
>>>t1=('karouch',2.3,6,'Offant')
>>>t1
('karouch',2.3,6,'Offant')
On peut y inclure des chaînes de caractères (grâce aux simples quotes) et en même temps des variables (entiers, booléens, flottants...).
>>>t1[1]
2.3
Renvoie le 2ème élément de la liste.
>>>t1[0]
Alors que t1[0] renvoie le 1er.
>>>t1=(1)
>>>t2=('ff',1,'e',1.2)
>>>t1+t2
(1,'ff',1,'e',1.2)
Fait un ensemble des variables des 2 tuples.
>>>t1*2
(1,1)
Fait un deuxième ensemble des variables dans le tuple 1.
>>>type(t1)
<class 'tuple'>
Nous donne le type de t1 --> Un tuple.
>>>t1=(1,2,3,5,6,8,9)
>>>t1[5]
8
Donne le 6ème élément de la liste (à cause du 0).
>>>t1[-1]
9
Donne le 1er élément en partant de la fin.
t1[4]=23
Error
Un tuple est non mutable, on ne peut modifier les variable quand le tuple est défini.
Les fonctions sont des suites d'inscription regroupées sous un même nom. Elles ne s'exécutent que si elles sont appelées.
Quand il y a 2 points au bout d'une ligne, la ligne suivante est indentée (décalée de 4 espaces).
Les fonctions sont écrites dans la partie gauche, c'est le script. En revanche, l'exécution de ce script (appuyer sur la flèche verte), se fait dans la console de droite.
Script :
def multiple (n) :
return (n, 2*n,3*n)
(a,b,c)=multiple(1)
print(a)
print(b)
print(c)
print(a,b,c)
print(multiple(1))
n est l’argument de la fonction.
Exécution du script :
1
2
3
1,2,3
(1,2,3)
Cela correspond aux réponses de print. On peut voir que pour donner les valeurs de a, de b et de c, on peut l'ordonner de différentes manières.
>>>t1=(1,2,3,5,6,8,9)
>>>2 in t1
True
>>>'Pages' in t1
False
Permet de vérifier si l'élément est dans le tuple t1. Vrai ou Faux --> Fonction booléenne
>>>L1=[1,2,3,5,9]
>>>type[L1]
<class 'list'>
>>>L1=[1.2,1,'Offant','e',(1,2,3)]
Dans la liste, on peut mettre des types différents des uns des autres.
>>> L2=[1,3,5,9,6]
>>> L1+L2
[1.2, 1, 'Offant', 'e', (1, 2, 3), 1, 3, 5, 9, 6]
>>> L1*2
[1.2, 1, 'Offant', 'e', (1, 2, 3), 1.2, 1, 'Offant', 'e', (1, 2, 3)]
Mêmes possibilités que pour les tuples.
>>> L1[3]
'e'
>>> L1[3]=4
>>> L1
[1.2, 1, 'Offant', 4, (1, 2, 3)]
Une liste est mutable, on peut modifier les valeurs après avoir défini la liste. C'est donc différents aux tuples.
>>> L1
[1.2, 1, 'Offant', 4, (1, 2, 3), 3]
On applique la méthode append à la liste L1 avec l'argument 3. Cela rajoute 3 à la fin de la liste.
>>> L1=[]
>>> L1
[]
Création d'une liste vide.
>>> L1=[i**2 for i in range(5)]
>>> L1
[0, 1, 4, 9, 16]
Compréhension de liste : i**2 --> i^2
For i in range(5) --> i prend 5 valeurs de 0 à 4.
>>> L1=[i**2 for i in range(0,5,2)]
>>> L1
[0, 4, 16]
Même instruction mais :
0 --> Point de départ
5 --> Valeur maximale
2 --> Intervalle
>>> L1=[i**2 for i in range(10) if i**2%2==0]
>>> L1
[0, 4, 16, 36, 64]
if... --> Condition pour i**2 :
Renvoie le reste de la division euclidienne de i**2 par 2 --> Cela s'exécute si celui-ci est 0 (i**2 doit être pair).
>>> L1=[i**2 for i in range(10) if i**2%2==1]
>>> L1
[1, 9, 25, 49, 81]
Contrairement au précédent, cela s'exécute si celui-ci est 1 (i**2 doit être impair).
>>> L2=[[3,4],[4,5],[5,6]]
>>> L2
[[3, 4], [4, 5], [5, 6]]
Il est donc possible de créer des listes de listes.
>>> L3=[[i*j for i in range(3)] j in range(5)]
>>>L3
[[0,0,0],[0,1,2],[0,2,4],[0,3,6],[0,4,8]]
Cela fait varier les valeurs de j et de i avec j*i.
Chaque liste correspond à une valeur de j multipliée aux 3 valeurs de i.
>>>len(L3)
5
La méthode len prend une liste comme argument (ici L3) et renvoie sa longueur (ici 5).
>>>L1=[1,2,3,5,9]
>>>5in L1
True
Vérifie si 5 appartient à la liste L1. Ici, c'est vrai (True).
Chapitre 6 : Architectures et systèmes d'exploitation
Pour commencer, nous travaillons sur Linux, car c'est un système d'exploitation libre, léger et qu'on peut accéder à tout ce que l'on veut dans un ordinateur.
Sur ce chapitre nous travaillons sur l'Émulateur Linux Bordas Édition. En première, il faut connaître quelques commandes de base.
Tout d'abord, pour naviguer entre les dossiers, il existe deux façons : le chemin relatif et le chemin absolu. Pour le chemin absolu, il faut d'abord écrire cd puis, un espace et enfin partir de la racine, c'est-à-dire précéder de / le chemin, puis marquer le chemin de tous les dossiers séparer par un /. En revanche, pour le chemin relatif, cela ne marche que de dossier en dossier, il faut, pour cela écrire cd Dossier en remplaçant le nom du dossier. Pour remonter de dossier en dossier, il faut marquer cd ../ en rajoutant des ../ en fonction du nombre de dossiers à remonter.
Ensuite, pour lister tous les fichiers d'un dossier il faut faire : ls. Si on veut détailler les dossiers pour avoir les droits, les dates de création... il faut écrire ls -l.
Pour ouvrir un fichier il faut taper cat Fichier (remplacer le nom). Pour créer un fichier, il faut écrire touch Fichier. En revanche, pour le supprimer, il faut taper rm Fichier.
Pour créer un dossier il faut faire la commande mkdir Dossier. Pour le supprimer, il faut taper rm -d (supprime dossiers vides) ou rm -r (supprime dossiers et fichiers).
Pour copier un fichier sur le même dossier, il faut écrire cp Doc Doc1 avec Doc, le fichier d'origine et Doc1, celui de copie. Si l'on veut copier un fichier sur un autre dossier, il faut alors indiquer le chemin de ce répertoire (avec chemin relatif ou absolu) cp Doc /Dossier/Doc1 avec comme chemin Dossier.
Pour déplacer un fichier dans un dossier, il faut utiliser la commande mv Doc Dossier : ici, cela déplace le fichier Doc dans le dossier Dossier.
Si l'on veut connaître le chemin du répertoire sur lequel on travaille, il faut écrire pwd.
Tout d'abord, il faut savoir qu'il existe des droits liés aux fichiers car plusieurs utilisateurs peuvent accéder à un environnement de travail Linux. On retrouve les droits de lecture (r), d'écriture (w) et d'exécution (x). Les différents types d'utilisateurs sont le propriétaire (u), le groupe d'utilisateurs (g) et les autres utilisateurs (o). La commande chmod permet de modifier ces droits. Si l'on veut ajouter des droits, il faut utiliser + et si l'on veut en retirer, utiliser -. Par exemple, si l'on veut retirer le droit d'exécution au groupe d'utilisateurs pour le fichier Doc, il faut écrire chmod g-x Doc.
Pour finir, 2 commandes assez similaires existent pour nous renseigner, avec la commande man qui ouvre un manuel pour la commande rm si l'on fait man rm et pour nous aider avec la commande --help sous forme rm --help, nous donnant toutes les possibilités de suffixe.