Dans un programme informatique, l’ordinateur va manipuler des informations. Il va faire des calculs et va stocker ses résultats dans sa mémoire, généralement la RAM.

Une mémoire de 4Go contient 2³² cases mémoire. On peut comparer la mémoire à un immeuble comprenant 4 294 967 296 étages, numérotés de 0 à 4 294 967 295. Chaque étage contient un octet.

Exemple de stockage de la chaîne de caractères PYTHON :

La difficulté pour le programmeur serait d'organiser lui-même la mémoire et savoir où commence et termine le mot PYTHON. Les langages de programmation permettent d'affecter à une variable cette chaîne de caractères : mettre dans une boite étiquetée langage, le mot PYTHON.

Pour affecter à la variable langage le mot PYTHON, il suffit de coder la ligne suivante :

langage = "PYTHON" 

Les variables peuvent aussi contenir des nombres entiers, décimaux, des couples (p-uplets)...

REGLES A RESPECTER :

• ne jamais utiliser d'espace pour nommer les variables, les remplacer le par - ou _
• éviter les caractères accentués.
• éviter les majuscules elles sont réservées aux classe.
• utiliser des noms de variable en liaison avec l'élément à stocker

Pour affecter (on dit aussi assigner) la valeur 17 à la variable nommée age :

>>> age = 17

La fonction print affiche la valeur de la variable :

>>> print(age)
17

La fonction type() retourne le type de la variable :

>>> type(age)
<type 'int'>

int est le type des nombres entiers.

>>> # ceci est un commentaire
>>> age = age + 1	# en plus court : age += 1
>>> print(age)
18
>>> age = age - 3	# en plus court : age -= 3
>>> print(age)
15
>>> age = age * 2	# en plus court : age *= 2
>>> print(age)
30

>>> a = 6*3-20
>>> print(a)
-2

>>> b = 25
>>> c = a + 2*b
>>> print(b,c) 		# ne pas oublier la virgule
25 48

L'opérateur // donne la division entière :

>>> d = 450//360
>>> print(d)
1

L'opérateur % donne le reste de la division (opération modulo) :

>>> reste = 450 % 360
>>> print(reste)
90

L'opérateur ** donne la puissance :

>>> mebioctet = 2**20
>>> print(mebioctet)
1048576

Travail à faire : Manipuler les variables

Faire les premiers exercices de sommes et contaténations de varibles, du site Inertnet silentteacher

Mission n°2 ☆ : Afficher la taille en octets et en bits d'un fichier de 536 Kio.

536 kio font :
548864 octets
4390912 bits

Mission n°3 ★ : Trouvez la clé

La clé du numéro de sécurité sociale 2690549588157 est 80

>>> b = 17.0 	# le séparateur décimal est un point (et non une virgule)
>>> print(b)
17.0
>>> type(b)
<type 'float'>

>>> c = 14/3
>>> print(c)
4.66666666667

>>> c = 14//3	# division entière
>>> print(c)
4.0

Notation scientifique :

>>> a = -1.784892e4
>>> print(a)
-17848.92

Mission n°4 ★ : Calculer et afficher le nombre photos d'une taille moyenne de 3.5 Mo qu'on peut stocker sur une clé de 64 Go.

début
taille_photos_Mo  ← 3.5
taille_cle_Go ← 64
nbr_photos ← taille clé en Mo divisé par taille des photos en Mo
Afficher "Nombre de photos :", nbr_photos 
nbr_photos ← taille clé en Mo division entière par taille des photos en Mo
Afficher "donc environ :", nbr_photos 
fin

Nombre de photos : 18285.71428571429
donc environ : 18285.0

Pour utiliser les fonctions mathématiques, il faut commencer par importer le module math :

>>> import math

La fonction dir() retourne la liste des fonctions et données d'un module :

>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan',
'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf',
'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',
'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',
'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

Pour appeler une fonction d'un module, la syntaxe est la suivante :
module.fonction(arguments)

Pour accéder à une donnée d'un module :
module.data

>>> print(math.pi)		# donnée pi du module math (nombre pi)
3.14159265359
>>> print(math.sin(math.pi/4)) # fonction sin() du module math (sinus)
0.707106781187
>>> print(math.sqrt(2)) 	# fonction sqrt() du module math (racine carrée)
1.41421356237
>>> print(math.sqrt(-5))
Traceback (most recent call last):
    print(math.sqrt(-5.0))
ValueError: math domain error
>>> print(math.exp(-3)) 	# fonction exp() du module math (exponentielle)
0.0497870683679
>>> print(math.log(math.e)) 	# fonction log() du module math (logarithme népérien)
1.0

Un cercle ayant un rayon de 20 cm aura une aire de 1256.637061435917 cm²

>>> nom = 'Dupont' 	# entre apostrophes
>>> print(nom)
Dupont
>>> type(nom)
<type 'str'>
>>> prenom = "Pierre" 	# on peut aussi utiliser les guillemets
>>> print(prenom)
Pierre
>>> print(nom,prenom) 	# ne pas oublier la virgule
Dupont Pierre

La concaténation désigne la mise bout à bout de plusieurs chaînes de caractères.
La concaténation utilise l'opérateur +

>>> chaine = nom + prenom 	# concaténation de deux chaînes de caractères
>>> print(chaine)
DupontPierre
>>> chaine = (prenom + nom) 	# concaténation de deux chaînes de caractères
>>> print(chaine)
PierreDupont
>>> chaine = prenom + ' ' + nom
>>> print(chaine)
Pierre Dupont
>>> chaine = chaine + ' 18 ans'	# en plus court : chaine += ' 18 ans'
>>> print(chaine)
Pierre Dupont 18 ans

La fonction len() retourne la longueur (length) de la chaîne de caractères :

>>> print(len(chaine))
20

>>> print(chaine[0])	# premier caractère (indice 0)
P
>>> print(chaine[1])	# deuxième caractère (indice 1)
i
>>> print(chaine[1:4])
ier
>>> print(chaine[2:])
erre Dupont 18 ans
>>> print(chaine[-1])	# dernier caractère (indice -1)
s
>>> print(chaine[-6:])
18 ans

>>> chaine = 'Aujourd'hui'
SyntaxError: invalid syntax
>>> chaine  = 'Aujourd\'hui'		# séquence d'échappement \'
>>> print(chaine)
Aujourd'hui
>>> chaine  = "Aujourd'hui"
>>> print(chaine)
Aujourd'hui

La séquence d'échappement \n représente un saut ligne :

>>> chaine = 'Première ligne\nDeuxième ligne'
>>> print(chaine)
Première ligne
Deuxième ligne

Plus simplement, on peut utiliser les triples guillemets (ou les triples apostrophes) pour encadrer une chaîne définie sur plusieurs lignes :

>>> chaine = """Première ligne
Deuxième ligne"""
>>> print(chaine)
Première ligne
Deuxième ligne

Mission n°6 ★ Afficher les initiales

Les initiales de Lea Martin sont : LM

Mission n°7 ★☆ Créer un identifiant

L'identifiant d'accès au réseau du lycée est construit de la manière suivante : initiale du prénom puis les 8 premiers caractères du nom (le tout en minuscule).
Exemple : Alexandre Lecouturier → alecoutur
A partir des deux variables prenom et nom, construire l'identifiant composé de lettres minuscules uniquement. (Voir Methode la lower)

Exécuter

On ne peut pas mélanger les serviettes et les torchons (ici type <type 'str'> et <type 'int'>) :

>>> chaine = '17.45'
>>> type(chaine)
<type 'str'>
>>> chaine = chaine + 2
TypeError: cannot concatenate 'str' and 'int' objects

La fonction float() permet de convertir un <type 'str'> en <type 'float'>

>>> nombre = float(chaine)
>>> print(nombre)
17.45
>>> type(nombre)
<type 'float'>
>>> nombre = nombre + 2		# en plus court : nombre += 2
>>> print(nombre)
19.45

La fonction input() lance une invite de commande (en anglais : prompt) pour saisir une chaîne de caractères.

>>> chaine = input("saisir une chaîne de caractères et valider avec la touche Entrée")
>>> # j'ai saisi 14.56 au clavier et validé avec la touche entrée
>>> print(chaine) 
14.56 
>>> type(chaine)
<type 'str'>
>>> nombre = float(chaine)	# conversion de type
>>> print(nombre**2)
211.9936

Un nombre décimal vers un entier : <type 'float'> vers <type 'int'>

>>> b = 17.5
>>> type(b)
<type 'float'>
>>> b=int(b)
>>> print(b)
17
>>> type(b)
<type 'int'>

Une chaine de caractères vers un entier : <type 'str'> vers <type 'int'>

>>> b = "120"
>>> b = b*2
>>> print(b)
120120
>>> type(b)
<type 'str'>
>>> b=int(b)
>>> print(b)
120120
>>> type(b)
<type 'int'>

Un nombre en une chaine de caractères : <type 'int'> vers <type 'str'>

>>> b = 50 	
>>> b = b * 2
>>> print(b)
100
>>> type(b)
<type 'int'>
>>> b = str(b)
>>> b = "0b" + b * 2
>>> print(b)
0b100100
>>> type(b)
<type 'str'>
>>> print(b[2])
1

Mission n°8 ★★☆ Conversion binaire → décimal

La variable binaire contient la chaine de caractère suivante '0b1101'

Additionner le produit de chaque 0 et 1 contenu dans la chaîne de caractère et de son poids

Afficher le résultat sous la forme suivante :

Le quartet binaire 0b1101 équivaut à 13 en décimal

Exécuter

Une liste est une structure de données.
Le premier élément d'une liste possède l'indice (l'index) 0 (comme la chaîne de caractères).
Dans une liste, on peut avoir des éléments de plusieurs types.

>>> infoPerso = ['Pierre' , 'Dupont' , 17 , 1.75 , 72.5]
>>> # la liste infoPerso contient 5 éléments de types str, str, int, float et float
>>> type(infoPerso)
<type 'list'>
>>> print(infoPerso)
['Pierre', 'Dupont', 17, 1.75, 72.5]
>>> print('Prénom : ',infoPerso[0])	# premier élément (indice 0)
Prénom :  Pierre
>>> print('age : ',infoPerso[2])	# le troisième élément a l'indice 2
age :  17
>>> print('Taille : ',infoPerso[3])	# le quatrième élément a l'indice 3
Taille :  1.75

La fonction range() crée une liste d'entiers régulièrement espacés :

>>> liste = list(range(10))
>>> print(liste)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(liste)
<type 'list'>

>>> liste = list(range(1,10,2))		# range(début,fin non comprise,intervalle)
>>> print(liste)
range(1, 10, 2)
>>> print(liste[2])
5

On peut créer une liste de listes, qui s'apparente à un tableau à 2 dimensions (ligne, colonne) :

>>> liste = list([[0,1,2],[10,11,12],[20,21,22]])
>>> print(liste[0])
[0, 1, 2]
>>> print(liste[0][0])
0
>>> print(liste[2][1])		# élément à la troisième ligne et deuxième colonne
21
>>> liste[2][1] = 69		# nouvelle affectation
>>> print(liste)
[[0, 1, 2], [10, 11, 12], [20, 69, 22]]

Mission n°9 : Convertir un entier compris entre 0 et 255 en Hexadécimal

Pour convertir l'entier décimal 207 en hexadécimal, on procède comme suit :

• Commencez par créer la liste hexa ci-dessus
• Affectez la valeur décimale 207 à convertir dans la variable dec
• Le résultat du calcul de la division entière entre dec et 16 sera stocké dans la variable quotient.
• Le résultat du calcul du reste de la division entre dec et 16 sera stocké dans la variable reste.
• Affichez le résultat par concaténation de chaines de caractères, en extrayant les caractères hexadécimaux de la liste hexa, aux index quotient et reste. Attention, dec est un entier qu'il faudra passer en string

Résultat exigé à l'espace prêt

Le nombre décimal 207 équivaut à 0xCF

Exécuter

Deux valeurs sont possibles : True et False

>>> a = True
>>> type(a)
<type 'bool'>

Les opérateurs de comparaison :

>>> b = 10
>>> print(b>8)
True
>>> print(b==5)
False
>>> print(b!=10)
False
>>> print(0<= b <=20)
True

Les opérateurs logiques : and, or, not

>>> note=13.0
>>> mentionAB = note>=12.0 and note<14.0 # ou bien : mentionAB = 12.0 <= note < 14.0
>>> print(mentionAB)
True
>>> print(not mentionAB)
False
>>> print(note==20.0 or note==0.0)
False

L'opérateur in s'utilise avec des chaînes (type str) ou des listes (type list) :

>>> chaine = 'Bonsoir'
>>> #  la sous-chaîne 'soir' fait-elle partie de la chaîne 'Bonsoir' ?
>>> a = 'soir' in(chaine)
>>> print(a)
True
>>> print('b' in(chaine))
False

>>> liste = list([4,8,15])
>>> #  le nombre entier 9 est-il dans la liste ?
>>> print(9 in(liste))
False
>>> print(8 in (liste))
True
>>> print(14 not in(liste))
True

On demande à l'utilisateur de rentrer son numréro de sécurité sociale complet avec sa clé sans espace ex : 269054958815780 (instruction input)

On stocke dans la variable numéro l'entier correspondant aux 13 premiers symboles rentrés

La clé correspond toujours au deux derniers chiffres du numéro de sécurité sociale saisi. (Revoir le type str)

Créer une variable booléenne dont le résultat sera True si le numéro calculé est égal au numéro saisi. (Revoir le calcul de la clé)

Résultat exigé :

Le numéro de sécurité sociale 2690549588157 et la clé 80 est True

Programme

Exécuter

Un dictionnaire stocke des données sous la forme clé ⇒ valeur.
Une clé est unique et n'est pas nécessairement un entier (comme c'est le cas de l'indice d'une liste).

>>> moyenne = {'math':12.5,'anglais':15.8}	# entre accolades
>>> type(moyenne)
<type 'dict'>
>>> print(moyenne['anglais'])		# entre crochets
15.8
>>> moyenne['anglais']=14.3		# nouvelle affectation
>>> print(moyenne)
{'anglais': 14.3, 'math': 12.5}
>>> moyenne['sport']=11.0		# nouvelle entrée
>>> print(moyenne)
{'sport': 11.0, 'anglais': 14.3, 'math': 12.5}

Mission n°11: recette du gâteau au chocolat selon Marmiton

On dispose du dictionnaire ingrédiants suivant, pour une personne :

ingrédients={"Beurre":15,"Chocolat":35,"Farine":10,"Sucre":15,"Oeufs":0.5}

La variable etape contient toutes les étapes de la recette

etapes='''Étape 1 : Préchauffer le four à 180°C.  Dans une casserole, faites fondre {} grammes de chocolat et {} grammes de beurre coupé en morceaux à feux doux.
Étape 2 : Dans un saladier, ajoutez {} grammes de sucre, {} oeufs, {} grammes de farine. Mélangez.
Étape 3 : Ajoutez le mélange chocolat/beurre. Mélangez bien.
Étape 4 : Beurrez et farinez votre moule puis y versez la pâte à gâteau.
Étape 5 : Faites cuire au four environ 20 minutes.
Étape 6 : A la sortie du four le gâteau ne paraît pas assez cuit. C'est normal, laissez-le refroidir puis démoulez-le.'''

Les accolades du texte seront remplacées par les ingrédiants

Utilisez la méthode format appliquée à une chaine de caractères décrite ci-dessous

Exemple :

>>>chanteuse={"nom":"Hoshi","Lieu":"Versailles","naissance":1996}
>>>print("{} est née en {} à {}".format(chanteuse["nom"],chanteuse["naissance"],chanteuse["Lieu"]))  
>>>Hoshi est née en 1996 à Versailles

Cette méthode permet de s'affranchir des conversions de types lors des concaténations de chaînes de caractères.

Déclarer les deux variables ingredients et etapes dans le programme et implantez l'instruction print qui permettra d'afficher la recette pour 1 personne.

Programme

Exécuter

Modifiez le programme qui demandera à l'utilisateur le nombre de personnes (avec un input) et vous modifierez la ligne print en fonction de ce nombre saisi.

Nous avons vu les types les plus courants.
Il en existe bien d'autres :

• long (nombres entiers de longueur quelconque, par exemple 4284961775562012536954159102L)
• complex (nombres complexes, par exemple 1+2.5j)
• tuple (structure de données)
• set (structure de données)
• file (fichiers)
• ...