Copyright (c) Yann Bouyeron.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
A copy of the license is included in the section entitled "GNU Free Documentation License".
Pour définir une variable, vous devez lui donner un nom sans espace et commençant obligatoirement par une lettre. Vous devez ensuite lui attribuer une valeur ou un contenu en utilisant le signe "=". Après avoir créé une variable, vous pouvez appeler cette variable dans le Shell en écrivant son nom, ce qui entraînera l'affichage de son contenu.
>>> ma_variable = 5
>>> ma_variable
5
Différents types de contenus peuvent être attribués à une variable:
>>> ma_variable = 5
>>> type(ma_variable)
<type 'int'>
>>> ma_variable2 = 5.0
>>> type(ma_variable2)
<type 'float'>
>>> ma_variable3 = "cinq"
>>> type(ma_variable3)
<type 'str'>
La fonction type(nom_de_la_variable) permet de connaître le type d'une variable préalablement définie.
Le type int : ce sont des nombres entiers relatifs.
Le type float : ce sont des nombres réels (avec un point représentant la virgule).
Le type str : ce sont des chaînes de caractères , qui doivent être écrites entre guillemets
Comme son nom l'indique, une variable peut varier !
>>> var = 2
>>> var
2
>>> var = 34
>>> var
34
Il est possible d'effectuer des opérations avec les entiers de type int et les réels de type float:
>>> a = 5
>>> b = 2
>>> a + b
7
>>> a - b
3
>>> a * b
10
>>> a / b
2.5
>>> a ** b
25
>>> a = 5.0
>>> b = 2
>>> a / b
2.5
Le résultat d'une opération peut être affecté à une variable :
>>> a = 5
>>> b = 2
>>> c = a + b
>>> c
7
>>> a = a + 10
>>> a
15
La méthode "bricolage"
>>> nom = 'Robert'
>>> age = '32'
>>> phrase = 'Bonjour ' + nom + ' vous avez ' + age + ' ans'
>>> phrase
'Bonjour Robert, vous avez 32 ans'
La méthode "pro"
>>> nom = 'Robert'
>>> age = 32
>>> phrase = 'Bonjour {n}, vous avez {a} ans'.format(n = nom, a = age)
>>> phrase
'Bonjour Robert, vous avez 32 ans'
En python >= 3.6
>>> nom = "Robert"
>>> age = 32
>>> phrase = f"Bonjour {nom}, vous avez {age} ans"
>>> phrase
'Bonjour Robert, vous avez 32 ans'
>>> a = 5
>>> type (a)
<type 'int'>
>>> b = float(a)
>>> b
5.0
>>> c = str(a)
>>> c
'5'
>>> d = int(c)
>>> d
5
Vous avez jusqu'à présent utilisé Python en mode Shell. Ce mode est très pratique pour écrire et interpréter "à la volée" des lignes de codes ; ce qui est idéal pour tester rapidement quelques lignes de codes.
Le désavantage étant que les lignes de codes écrites ne peuvent être sauvegardées ni même corrigées; en cas d'erreurs il faut tout ré écrire !
Pour remédier à cela, il existe un mode "éditeur" qui permet de sauvegarder son code.
Pour accéder à l'éditeur, allez dans "File" puis cliquez "New File"; une page dans laquelle vous pourrez écrire votre code s'ouvre alors.
Indiquer toujours cette ligne en haut de votre page: # coding: utf-8 afin de fixer l'encodage du texte (c'est inutile sur Python 3)
Pour interpréter votre code, cliquez sur F5; après avoir attribué un nom à votre algorithme se terminant en .py , cliquez à nouveau sur F5.
Pour ré ouvrir un algorithme déjà enregistré, allez dans "File", puis "open", et recherchez le nom de votre algorithme.
Votre algorithme peut interagir avec l'utilisateur, en lui demandant d'entrer des informations que vous attribuerez à des variables.
En Python3, la fonction input permet d’entrer des int, float, ou str qui seront automatiquement transformés en str
nom = input('Entrez votre nom: ')
age = input('Entrez votre age: ')
phrase = 'Bonjour {n} , vous avez {a} ans'.format(n = nom, a = age)
- Utiliser la fonction
inputpour demander à l'utilisateur d'entrer un nombre de type int ou float. - Utiliser la fonction
raw_inputpour demander à l'utilisateur d'entrer une chaîne de caractères de type str.
Vous pouvez en retour, envoyer des informations à l'utilisateur. Pour cela , utilisez la fonction print
nom = input('Entrez votre nom: ')
age = input('Entrez votre age: ')
phrase = 'Bonjour {n} , vous avez {a} ans'.format(n = nom, a = age)
print (phrase)
Un booléen est un type de variable à deux états. Les variables de ce type sont ainsi soit à l'état vrai (True) soit à l'état faux (False). Les booléens permettent de faire des comparaisons:
>>> a = 4
>>> b = 2
>>> c = 'maristes'
>>> a == b
False
>>> a == 4
True
>>> a < b
False
>>> a <= b
False
>>> a > b
True
>>> a >= b
True
>>> a != b
True
>>> a != 'ok'
True
>>> type(a) == type(b)
True
>>> type(a) == type(c)
False
>>> c == 'maristes'
True
>>> c == 'Maristes'
False
a = 4 et la comparaison a == 4 !!!
age = input('Entrez votre age: ')
age = int(age)
if age >= 18:
print('Vous êtes majeur')
else:
print('Vous êtes mineur')
Si l'âge est supérieur ou égal à 18, les instructions du bloc suivant le if sont exécutées (il n'y a qu'une seule instruction : print('Vous êtes majeur')) , mais on peut mettre plusieurs instructions dans le bloc si on le souhaite.
Sinon (autrement dit si l'âge est inférieur à 18) ce sont les instructions du bloc suivant le else qui sont exécutées.
age = input('Entrez votre age: ')
age = int(age)
if age > 18:
print('Vous êtes majeur')
elif age == 18:
print('Vous êtes majeur depuis cette année')
else:
print('Vous êtes mineur')
elif signifie sinon et si
Il est possible d'utiliser if sans elif ou sans else , de même qu'il est possible d'utiliser if avec elif mais sans else
age = input('Entrez votre age: ')
age = int(age)
if age > 18:
print('Vous êtes majeur')
if age == 18:
print('Vous êtes majeur depuis cette année')
if age < 18:
print('Vous êtes mineur')
age = input('Entrez votre age: ')
genre = input('Entrez votre genre (H ou F): ')
age = int(age)
if age >= 18 and genre == 'H':
print('Vous êtes un homme majeur')
elif age >= 18 and genre == 'F':
print('Vous êtes une femme majeure')
elif age < 18 and genre == 'M':
print ('Vous êtes un homme mineur')
else:
print ('Vous êtes une femme mineure')
L'exemple ci-dessus utilise le connecteur logique and, les 2 conditions situées de part et d'autre du and doivent être vérifiées pour que le bloc d'instructions soit exécuté .
Lorsque qu'on utilise le connecteur logique or, seule l'une des deux conditions situées de part et d'autre du or doit être vérifiée pour que le bloc d'instructions soit exécuté .
L'algorithme ci dessous est identique au précédant sauf qu'il n'utilise pas de connecteurs logiques. Regardez bien l'imbrication et l'indentation des blocs d'instructions.
age = input('Entrez votre age: ')
genre = input('Entrez votre genre (H ou F): ')
age = int(age)
if age >= 18:
if genre == 'H':
print('Vous êtes un homme majeur')
elif genre == 'F':
print('Vous êtes une femme majeure')
elif age < 18:
if genre == 'M':
print ('Vous êtes un homme mineur')
elif genre == 'F':
print ('Vous êtes une femme mineure')
En anglais "while" signifie "tant que".
Cette fonction de python permet de créer des boucles: Tant que (while) la condition booléenne est vérifiée alors les instructions du bloc d'instructions sont réalisées.
n = int(input('Entrez un nombre supérieur à 100: '))
while n < 100:
print("""Vous n'avez pas respecté la consigne !!! \n""")
n = int(input('Entrez un nombre supérieur à 100: '))
print ("""C'est bien, vous avez respecté la consigne.""")
On demande à l'utilisateur d'entrer un nombre supérieur à 100, et on affecte ce nombre à la variable n.
On utilise ensuite la fonction while pour vérifier la condition booléenne n < 100 .
Tant que la valeur affectée à la variable n est inférieure à 100 , autrement dit tant que l'utilisateur n'a pas respecté la consigne, on exécute les deux instructions du bloc d'instructions faisant suite au while:
- on lui affiche un message pour le réprimander:
print("""Vous n'avez pas respecté la consigne !!! \n""") - on lui redemande d'entrer un nombre supérieur à 100:
n = int(input('Entrez un nombre supérieur à 100: '))
L'algorithme va ensuite revérifier la condition booléenne n < 100 , et tant qu'elle serra vérifiée , autrement dit tant que la consigne ne serra pas respectée , la boucle while se répétera.
Lorsque l'utilisateur entrera un nombre supérieur à 100, la condition booléenne n < 100 ne serra plus vérifiée et le bloc d'instruction de la boucle while ne serra pas exécuté. L'algorithme se poursuivra et se terminera en exécutant le print ("""C'est bien, vous avez respecté la consigne.""") qui est situé hors du bloc d'instruction de la boucle while
nombre_de_chances_max = 100
nombre_de_chances_utilisees = 0
reponse = int(input('Les cours Sainte Marie de Hann ont été fondés en quelle année ? '))
bonne_reponse = 1950
while nombre_de_chances_utilisees < nombre_de_chances_max:
if reponse != bonne_reponse:
nombre_de_chances_utilisees = nombre_de_chances_utilisees + 1
print('Mauvaise réponse, il vous reste {x} chances \n'.format(x = nombre_de_chances_max-nombre_de_chances_utilisees))
reponse = int(input('Les cours Sainte Marie de Hann ont été fondés en quelle année ? '))
else:
print("Bravo, c'est la bonne réponse !")
break
>>> z =[1,2,3,4]
>>> z
[1, 2, 3, 4]
>>> type(z)
<type 'list'>
>>> u = list('1234')
>>> u
['1', '2', '3', '4']
>>> type(u)
<type 'list'>
En Python3:
>>> a = range(20)
>>> a
range(0, 20)
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> type(a)
<type 'list'>
En Python2.7:
>>> a = range(20)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> type(a)
<type 'list'>
>>> fruits = ['pomme', 'poire', 'fraise', 'orange']
>>>
>>> listecombinee = ['pomme', 3, 'orange', 2.543]
Création d'une liste nommée "maliste":
>>> maliste = [1,2,3,4,5]
La fonction len() indique la longueur de la liste, c'est à dire le nombre d'éléments dans la liste:
>>> len(maliste)
5
La fonction max() indique le nombre le plus élevé d'une liste de nombres, ou le dernier élément alphabétique d'une liste de mots
>>> max(maliste)
5
La fonction min() indique le nombre le plus petit d'une liste de nombres, ou le premier élément alphabétique d'une liste de mots
>>> min(maliste)
1
Python compte toujours à partir de 0. maliste[0] renvoie le premier élément de la liste intitulée "maliste", c'est à dire l'élément d'index 0 de la liste
>>> maliste[0]
1
>>> maliste[4]
5
La fonction sum() indique la somme des éléments de la liste:
>>> sum(maliste)
15
>>> a = [1,2,3,4]
>>> a + [1]
[1, 2, 3, 4, 1]
Ou en utilisant la fonction append:
>>> a = [1,2,3,4]
>>> a.append(1)
>>> a
[1, 2, 3, 4, 1]
>>> a = [1,2,3,4]
>>> a[1] = 333
>>> a
[1, 333, 3, 4]
>>> a = [1,2,3,4]
>>> a.insert(1,5555)
>>> a
[1, 5555, 2, 3, 4]
Dans l'ordre croissant:
>>> a = [2,1,4,3]
>>> a.sort()
>>> a
[1, 2, 3, 4]
Dans l'ordre décroissant:
>>> a = [1,2,3,4]
>>> a.sort(reverse = True)
>>> a
[4, 3, 2, 1]
Inverser l'ordre:
>>> a = [2,1,4,3]
>>> a.reverse()
>>> a
[3, 4, 1, 2]
>>> a = [1,2,3,4]
>>> a.remove(3)
>>> a
[1, 2, 4]
Pour tous les éléments (appelés ici "i") de la liste a , on affiche chaque élément i multiplié par 2
>>> a = [1,2,3,4]
>>> for i in a:
... print(i*2)
...
2
4
6
8
La liste b est une liste vide. Pour tous les éléments i de la liste a , on affecte à la variable x le produit i*2 , et on ajoute la valeur de x à la liste b.
>>> a = [1,2,3,4]
>>> b = []
>>>
>>> for i in a:
... x = i*2
... b.append(x)
...
>>> b
[2, 4, 6, 8]
La fonction enumerate() permet de parcourir une liste et d'obtenir l'index (position de l'élément dans la liste) et la valeur de chaque élément.
>>> fruits
['pomme', 'poire', 'fraise', 'orange']
>>> for i, v in enumerate(fruits):
... print ('index {0} valeur {1}'.format(i, v))
...
index 0 valeur pomme
index 1 valeur poire
index 2 valeur fraise
index 3 valeur orange
>>> fruits
['pomme', 'poire', 'fraise', 'orange']
>>> fruits.index('poire')
1
>>> s = 'bonjour comment ca va ?'
>>> p = s.split(' ')
>>> p
['bonjour', 'comment', 'ca', 'va', '?']
>>> p
['bonjour', 'comment', 'ca', 'va', '?']
>>> q = " ".join(p)
>>> q
'bonjour comment ca va ?'
>>> p
['bonjour', 'comment', 'ca', 'va', '?']
>>> p[1:]
['comment', 'ca', 'va', '?']
>>> p[2:4]
['ca', 'va']
>>> p[:4]
['bonjour', 'comment', 'ca', 'va']
>>> p[:1]
['bonjour']
Il faut pour cela importer le module random:
import random
On peut utiliser la fonction random.choice() :
>>> import random
>>> a = range(20)
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> h = random.choice(a)
>>> h
3
>>> h = random.choice(a)
>>> h
14
L'algorithme ci dessus choisit au hasard un élément dans la liste a
On peut aussi utiliser la fonction random.randint():
>>> import random
>>> x = random.randint(0,20)
>>> x
4
>>> x = random.randint(0,20)
>>> x
20
L'algorithme ci dessus choisit au hasard un nombre compris entre 0 et 20
>>> x = ['peche','pomme','poire','abricot']
>>> y = len(x)
>>> y
4
>>> x[3]
'abricot'
>>> x[4]
Traceback (most recent call last):
File "<string>", line 1, in <module>
IndexError: list index out of range
>>> x[4-y]
'peche'
>>> x[-1]
'abricot'
>>> x[-1] == x[y-1]
True
>>> x = list(range(10))
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> 2 in x
True
>>>
>>>
>>> 2 not in x
False
Les dictionnaires sont des objets qui associent des clés à des valeurs. Les clés et les valeurs peuvent être des chaînes de caractères (str), des entiers (int), des réels (float), des listes (list) ou des tuples (tuple) ou des listes de tuples...
>>> dico = {'clé1': 'valeur1', 'clé2': 'valeur2', 'clé3': 'valeur3'}
>>> dico
{'clé2': 'valeur2', 'clé3': 'valeur3', 'clé1': 'valeur1'}
Il existe plusieurs manières de créer un dictionnaire:
>>> d = {'fruit1':'pomme', 'fruit4': 'orange', 'fruit3': 'poire'}
>>> d
{'fruit3': 'poire', 'fruit1': 'pomme', 'fruit4': 'orange'}
>>> d2 = dict(a = 45, b = 3, c= 532)
>>> d2
{'b': 3, 'c': 532, 'a': 45}
>>> d3 = dict( [ (1,'un'), (2,'deux'), (3,'trois')] )
>>> d3
{1: 'un', 2: 'deux', 3: 'trois'}
>>> d['fruit1']
'pomme'
>>> d
{'fruit1': 'pomme', 'fruit3': 'poire', 'fruit4': 'orange'}
>>> d['fruit2'] = 'citron'
>>> d
{'fruit1': 'pomme', 'fruit2': 'citron', 'fruit3': 'poire', 'fruit4': 'orange'}
>>> d['fruit1']= 'banane'
>>> d
{'fruit1': 'banane', 'fruit2': 'citron', 'fruit3': 'poire', 'fruit4': 'orange'}
>>> d
{'fruit3': 'poire', 'fruit2': 'citron', 'fruit1': 'banane', 'fruit4': 'orange'}
>>> del(d['fruit4'])
>>> d
{'fruit3': 'poire', 'fruit2': 'citron', 'fruit1': 'banane'}
>>> d.keys()
dict_keys(['fruit1', 'fruit2', 'fruit3'])
>>> d.values()
dict_values(['pomme', 'citron', 'poire'])
Les deux méthodes ci-dessous sont équivalentes.
>>> for k,v in d.items():
... print(k, '=', v)
...
fruit1 = banane
fruit2 = citron
fruit3 = poire
fruit4 = orange
>>> for k in d.keys():
... print (k, '=', d[k])
...
fruit1 = banane
fruit2 = citron
fruit3 = poire
fruit4 = orange
Ce module permet de faciliter l’utilisation d’un dictionnaire :
>>> from attrdict import AttrDict
>>> d = {"fruit":"pomme"}
>>> a = AttrDict(d)
>>> a.fruit
'pomme'
>>> a['fruit']
'pomme'
Autre exemple:
>>> attr = AttrDict({'fruit': {'agrume': 'orange'}})
>>> attr.fruit.agrume
'orange'
>>> c = 'salut comment ca va'
>>> d = """salut l'ami"""
>>> d
"salut l'ami"
>>> len(c)
19
>>> max(c)
'v'
>>> min(c)
' '
>>> for v in c:
... print v
...
s
a
l
u
t
c
o
m
m
e
n
t
c
a
v
a
>>> for i, v in enumerate(c):
... print i, v
...
0 s
1 a
2 l
3 u
4 t
5
6 c
7 o
8 m
9 m
10 e
11 n
12 t
13
14 c
15 a
16
17 v
18 a
>>> c[2]
'l'
Retrouver l'index d'un caractère (si le caractère est présent plusieurs fois , seul son premier index serra affiché)
>>> c.index('t')
4
>>> c.capitalize()
'Salut comment ca va'
>>> c.upper()
'SALUT COMMENT CA VA'
Utilisez la fonction lower() pour passer des majuscules aux minuscules
>>> c.replace('t','y')
'saluy commeny ca va'
>>> c.replace('t','')
'salu commen ca va'
>>> c.replace(' ','')
'salutcommentcava'
c = ' bonjour '
>>> c.strip()
'bonjour'
>>> c = 'salut comment ca va'
>>> c[:5]
'salut'
>>> c[6:13]
'comment'
>>> c[17:]
'va'
>>> s = 'bonjour comment ca va ?'
>>> p = s.split(' ')
>>> p
['bonjour', 'comment', 'ca', 'va', '?']
>>> p
['bonjour', 'comment', 'ca', 'va', '?']
>>> q = " ".join(p)
>>> q
'bonjour comment ca va ?'