[[{"title":"Python","posi":0},{"text":"

Une variable est un espace mémoire dans lequel il est possible de stocker une valeur (une donnée).

Ouvrir IDLE :
Démarrer → Programmes → Python → IDLE (Python GUI)

Tester le code ci-dessous dans l'environnement de développement python  IDLE;

Le nom d'une variable s'écrit avec des lettres (non accentuées), des chiffres ou bien l'underscore _
Le nom d'une variable ne doit pas commencer par un chiffre.

En langage Python, l'usage est de ne pas utiliser de lettres majuscules pour nommer les variables (celles-ci sont réservées pour nommer les classes).

Exemple : age, mon_age, temperature1

A éviter : Age, AGE, MonAge, monAge, Temperature1

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)\n

Tester le code ci-dessus et conclure.

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

>>> print(type(age))\n

int est le type des nombres entiers.

>>> # ceci est un commentaire\n>>> age = age + 1\t# en plus court : age += 1\n>>> print(age)\n\n>>> age = age - 3\t# en plus court : age -= 3\n>>> print(age)\n\n>>> age = age*2\t\t# en plus court : age *= 2\n>>> print(age)\n

>>> a = 6*3 - 20\n>>> print(a)\n

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

>>> tour = 450//360\n>>> print(tour)\n

>>> angle = 450%360\n>>> print(angle)\n

>>> mo = 2**20\n>>> print(mo)\n\n>>> racine2 = 2**0.5\n>>> print(racine2)\n

>>> b = 17.0 \t# le séparateur décimal est un point (et non une virgule)\n>>> print(b)\n\n>>> print(type(b))>>> c = 14.0/3.0\n

>>> print(c)>>> c = 14.0//3.0\t# division entière\n

>>> print(c)\n

>>> c = 14/3\n>>> print(c)\n

La notation scientifique avec e

>>> a = -1.784892e4\n>>> print(a)\n

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)\n

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)\t\t# donnée pi du module math (nombre pi)\n\n>>> print(math.sin(math.pi/4.0)) # fonction sin() du module math (sinus)\n\n>>> print(math.sqrt(2.0)) \t# fonction sqrt() du module math (racine carrée)\n\n>>> print(math.sqrt(-5.0))\n\n>>> print(math.exp(-3.0)) \t# fonction exp() du module math (exponentielle)\n\n>>> print(math.log(math.e)) \t# fonction log() du module math (logarithme népérien)\n

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

>>> print(len(chaine))\n

In

Indexage et slicing

>>> print(chaine[0]) \t# premier caractère (indice 0)\n\n>>> print(chaine[1])\t# deuxième caractère (indice 1)\n\n>>> print(chaine[1:4])\t# slicing\n\n>>> print(chaine[2:])\t# slicing\n\n>>> print(chaine[-1])\t# dernier caractère (indice -1)\n\n>>> print(chaine[-6:])\t# slicing\n

En résumé :

 +---+---+---+---+---+---+\n | M | u | r | i | e | l |\n +---+---+---+---+---+---+\n 0   1   2   3   4   5   6\n-6  -5  -4  -3  -2  -1

 Il faut faire attention avec les apostrophes et les guillemets.

>>> chaine = 'Aujourd'hui'\n\n>>> chaine  = 'Aujourd\\'hui'\t\t# séquence d'échappement \\'\n>>> print(chaine)\n\n>>> chaine  = \"Aujourd'hui\"\n>>> print(chaine)\n

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

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

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\n\n>>> print(chaine)\n

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

>>> chaine = '17.45'\n>>> print(type(chaine))\n\n>>> chaine = chaine + 2\n

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

>>> nombre = float(chaine)\n>>> print(nombre)\n\n>>> print(type(nombre))\n\n>>> nombre = nombre + 2\t\t# en plus court : nombre += 2\n>>> print(nombre)\n

L

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

>>> # saisir une chaîne de caractères et valider avec la touche Enter\n>>> chaine = input(\"Entrer un nombre : \")\n\n>>> print(chaine)\n\n>>> print(type(chaine))\n\n>>> nombre = float(chaine)\t# conversion de type\n>>> print(nombre**2)\n

Une liste est une structure de données.

Le premier élément d'une liste possède l'indice (l'index) 0.
Dans une liste, on peut avoir des éléments de plusieurs types.

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

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

>>> maliste = range(10)\n>>> print(list(maliste))\n\n>>> print(type(maliste))\n

>>> maliste = range(1,10,2)\t# range(début,fin non comprise,intervalle)\n>>> print(list(maliste))\n\n>>> print(maliste[2])\t\t# le troisième élément a l'indice 2\n

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

 0  1  2
10 11 12
20 21 22

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

5

Deux valeurs sont possibles : True et False

>>> choix = True\n>>> print(type(choix))\n

:

>>> b = 10\n>>> print(b > 8)\n\n>>> print(b == 5)\n\n>>> print(b != 10)\n\n>>> print(0 <= b <= 20)\n

Les opérateurs logiques : and, or, not

>>> note = 13.0\n>>> mention_ab = note >= 12.0 and note < 14.0 # ou bien : mention_ab = 12.0 <= note < 14.0\n>>> print(mention_ab)\n\n>>> print(not mention_ab)\n\n>>> print(note == 20.0 or note == 0.0)\n

L'

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

>>> chaine = 'Bonsoir'\n>>> # la sous-chaîne 'soir' fait-elle partie de la chaîne 'Bonsoir' ?\n>>> resultat = 'soir' in chaine\n>>> print(resultat)\n\n>>> print('b' in chaine)\n

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

6

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).

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

Nous avons vu les types les plus courants.

Il en existe bien d'autres :

• complex (nombres complexes, par exemple 1+2.5j)
• tuple (structure de données)
• set (structure de données)
• file (fichiers)
• ...

Python est un langage de programmation orienté objet (comme les langages C++, Java, PHP, Ruby...).

Une variable est en fait un objet d'une certaine classe.

Par exemple, la variable amis est un objet de la classe list.
On dit aussi que la variable amis est une instance de la classe list.
L'instanciation (action d'instancier) est la création d'un objet à partir d'une classe (syntaxe :NouvelObjet = NomdelaClasse(arguments)) :

>>> # instanciation de l'objet amis de la classe list\n>>> amis = ['Nicolas', 'Julie']\t# ou bien : amis = list(['Nicolas', 'Julie'])\n>>> print(type(amis))\n

U

Une classe possède des fonctions que l'on appelle méthodes et des données que l'on appelle attributs.

La méthode append() de la classe list ajoute un nouvel élément en fin de liste :

>>> # instanciation d'une liste vide\n>>> amis = []\t\t\t# ou bien : amis = list()\n>>> amis.append('Nicolas')\t# synthase générale : objet.méthode(arguments)\n>>> print(amis)\n\n>>> amis.append('Julie')\t# ou bien : amis = amis + ['Julie']\n>>> print(amis)\n\n>>> amis.append('Pauline')\n>>> print(amis)\n

>>> amis.sort()\t\t\t# la méthode sort() trie les éléments\n>>> print(amis)\n

>>> amis.reverse()\t\t# la méthode reverse() inverse la liste des éléments\n>>> print(amis)\n

La méthode lower() de la classe str retourne la chaîne de caractères en casse minuscule :

>>> # la variable chaine est une instance de la classe str\n>>> chaine = \"BONJOUR\"\t\t# ou bien : chaine = str(\"BONJOUR\")\n>>> chaine2 = chaine.lower()\t# on applique la méthode lower() à l'objet chaine\n>>> print(chaine2)\n\n>>> print(chaine)\n

La méthode pop() de la classe dict supprime une clé :

>>> # instanciation de l'objet moyennes de la classe dict\n>>> moyennes = {'sport': 11.0, 'anglais': 14.3, 'math': 12.5}\n>>> # ou : moyennes = dict({'sport': 11.0, 'anglais': 14.3, 'math': 12.5})\n>>> moyennes.pop('anglais')\n\n>>> print(moyennes)\n

>>> print(moyennes.keys()) \t# la méthode keys() retourne la liste des clés\n

>>> print(moyennes.values()) \t# la méthode values() retourne la liste des valeurs\n

Afficher la taille en octets et en bits d'un fichier de 536 ko.
On donne : 1 ko (1 kilooctet) = 2¹⁰ octets !!!
1 octet = 1 byte = 8 bits

Affectez les variables temps et distance par les valeurs 6.892 et 19.7. Calculez et affichez la valeur de la vitesse. Améliorez l’affichage en imposant un chiffre après le point décimal.E

Le numéro de sécurité sociale est constitué de 13 chiffres auquel s'ajoute la clé de contrôle (2 chiffres).
Exemple : 1 89 11 26 108 268 91
La clé de contrôle est calculée par la formule : 97 - (numéro de sécurité sociale modulo 97)
Retrouver la clé de contrôle de votre numéro de sécurité sociale.
Quel est l'intérêt de la clé de contrôle ?

A partir des deux variables prenom et nom, afficher les initiales (par exemple LM pour Léa Martin).

Afficher la valeur numérique de √(4,6³ - 15/16)
Comparer avec votre calculette.

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.

On donne un extrait des logins d'accès au réseau du lycée :

alecoutur  Huz4\nlmartin    monty\nfsincere   gnugpl

1) Créer une variable de type dict qui contient les couples identifiant - mot de passe ci-dessus.
2) La saisie du login fournit deux variables identifiant et motdepasse : une pour l'identifiant et l'autre pour le mot de passe.
Construire une variable booléenne qui donne True en cas d'identification correcte, et False dans le cas contraire :
lmartin monty → True
alecoutur fqsdf → False
martin monty → False (ce cas est plus compliqué à traiter)