Introduction à la programmation Python

id: 33-1180-python-introduction-programmation slug: 33-1180-python-introduction-programmation titre: Introduction à la programmation Python chapitre: 1 chapitre_titre: Découverte du langage Python lecon: 1 niveau: 4eme-sci ordre: 1 prerequis: [] duree_estimee_min: 90 mots_cles:

• python
• variables
• types
• booleen
• chaine
• liste
• dictionnaire
• boucle
• condition
• fonction langages:
• python objectifs:
• Écrire des programmes simples en Python
• Distinguer les différents types de données (numérique, chaîne, booléen)
• Utiliser les structures conditionnelles et les boucles
• Manipuler des listes et des dictionnaires
• Importer et utiliser des modules status: published source_pdf: 33_1180.pdf source_pages:
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 57
• 58
• 59
• 60
• 61
• 62
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100 kind: cours

Présentation du cours

Python est un langage de programmation facile à apprendre. Vous pouvez l'utiliser pour créer des applications web, des jeux, et même un moteur de recherche !

Ce cours présente les aspects fondamentaux de la programmation en Python. À la fin du cours, vous saurez :

• Écrire des programmes informatiques simples en Python
• Automatiser l'analyse de données
• Comprendre les concepts de programmation transférables à d'autres langages

Premier programme

print "Welcome to Python!"

Sortie :

Welcome to Python!

Les variables

La création d'applications implique de stocker et de travailler avec différents types de données. On le fait en utilisant des variables.

my_var = 10
print "la valeur de mon variable =", my_var

Sortie :

la valeur de mon variable = 10

Types de variables

Les variables peuvent être de l'un des types suivants :

• Numérique
• Chaîne de caractères (alphanumérique)
• Booléen

Les variables numériques sont susceptibles de recevoir des nombres. Il existe plusieurs types numériques :

my_int = 7
my_float = 1.23
print "la valeur de mon variable", my_float

L'instruction d'affectation

spam = 5
ping = 9

On peut affecter à une variable le contenu d'une autre variable :

spam = ping

On peut aussi incrémenter une variable sans en utiliser une autre :

spam = spam + 1

Exemple de trace

A = 10
B = A + 3
A = 3
print "A = ", A
print "B = ", B

A = 5
B = 6
C = A
A = B
B = C
print "A = ", A
print "B = ", B
print "C = ", C

A = 6
B = 5
C = 5

Les booléens

Les nombres sont un type de données. Un deuxième type s'appelle un booléen.

a = True
b = False

Les commentaires

Les commentaires rendent votre programme plus facile à comprendre.

• Le signe # introduit un commentaire d'une ligne. Python n'essaiera pas de l'exécuter.
• Pour un commentaire multi-ligne, on peut l'inclure entre des triples guillemets """ ... """.

# Ceci est un commentaire d'une ligne

""" 
Ceci est un commentaire
sur plusieurs lignes.
"""

Les opérations mathématiques

On peut ajouter, soustraire, multiplier et diviser des nombres :

addition = 72 + 23
subtraction = 108 - 204
multiplication = 108 * 0.5
division = 108 / 9

Exponentiation

L'opérateur ** permet de calculer une puissance :

eight = 2 ** 3   # 2 puissance 3 = 8
eggs = 10 ** 2   # 10 puissance 2 = 100
print eggs

Sortie : 100

Modulo

L'opérateur modulo % renvoie le reste d'une division.

spam = 7 % 4
print spam

Sortie : 3 (car 7 = 4×1 + 3)

Les chaînes de caractères (strings)

Un autre type de données utile est la chaîne de caractères. Une chaîne peut contenir des lettres, des chiffres et des symboles. Les chaînes doivent être entre guillemets.

name = "Ryan"
age = "19"
food = "cheese"

Accès par index

Chaque caractère d'une chaîne possède un indice (numéro) :

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5

fifth_letter = "MONTY"[4]
print fifth_letter

Sortie : Y

Fonctions intégrées

Les fonctions intégrées (built-in) sont les fonctions prédéfinies dans le langage. Elles sont peu nombreuses : seulement celles utilisées très fréquemment.

Méthodes de chaînes

Nous étudions 4 méthodes principales :

• len() — longueur d'une chaîne
• lower() — passage en minuscules
• upper() — passage en majuscules
• str() — conversion en chaîne

parrot = "Norwegian Blue"
print len(parrot)

Sortie : 14

lower() et upper()

parrot = "Norwegian Blue"
print parrot.lower()
print parrot.upper()

Sortie :

norwegian blue
NORWEGIAN BLUE

str()

str() transforme une valeur (non-chaîne) en chaîne :

str(2)   # devient "2"

Afficher avec print

L'éditeur est la zone où l'on écrit le code. La console est l'endroit où s'affichent les résultats.

count = 1000
print "Imprimer dans la console"
print count
print "Imprimer un variable", count

Sortie :

Imprimer dans la console
1000
Imprimer un variable 1000

Concaténation de chaînes

L'opérateur + entre deux chaînes les concatène (les ajoute l'une après l'autre).

print "Life " + "of " + "Brian"

Sortie : Life of Brian

print "Spam" + " and " + "eggs"

Les modules et l'importation

Tous les calculs ne sont pas disponibles d'office. Par exemple :

print sqrt(25)

provoque l'erreur :

NameError: name 'sqrt' is not defined

Pour utiliser un module, il faut l'importer au début du programme.

Importation générique

import math
print math.sqrt(25)

Importation de fonction

Pour n'importer qu'une seule fonction :

from math import sqrt
print sqrt(25)

Importation universelle

Pour importer tout le contenu d'un module sans devoir préfixer :

from math import *
print sqrt(25)

Le flux de contrôle

Jusqu'à présent, nos programmes exécutaient toujours les mêmes instructions. Le flux de contrôle nous donne la possibilité de choisir parmi plusieurs résultats en fonction de conditions.

Les comparateurs

Il existe six comparateurs :

Exemples :

3 == 3    # True
3 == 6    # False
3 != 6    # True
3 < 6     # True
6 >= 6    # True

Les opérateurs booléens

Les opérateurs booléens combinent des expressions et produisent une valeur booléenne.

and — les deux instructions sont vraies

2 < 3 and 3 < 4   # True
2 > 3 and 3 < 4   # False

or — au moins une instruction est vraie

2 < 3 or 3 < 4   # True
2 > 3 or 3 > 4   # False

not — donne l'opposé

not False    # True
not 2 > 3    # True
not 3 < 4    # False

Ordre d'évaluation

Les opérateurs booléens sont évalués dans cet ordre :

1. not en premier
2. and ensuite
3. or en dernier

Les parenthèses permettent de forcer l'ordre d'évaluation.

L'instruction conditionnelle

L'instruction if

L'instruction if exécute du code si une condition est vraie.

if 8 < 9:
    print "Eight is less than nine!"

Ici, 8 < 9 est l'expression conditionnelle. Si elle est vraie, l'instruction print est exécutée.

reponse = input("Entrer un numero ! ")
if reponse > 0:
    print "Ton numero est positif"

L'instruction else

L'instruction else complète if. Une paire if/else signifie :

Si cette expression est vraie, exécute ce bloc, sinon exécute ce code après else.

if 8 > 9:
    print "I don't get printed!"
else:
    print "I get printed!"

L'instruction elif

elif est l'abréviation de "else if". Il signifie : sinon, si l'expression suivante est vraie, fais ceci.

if 8 > 9:
    print "I don't get printed!"
elif 8 < 9:
    print "I get printed!"
else:
    print "I also don't get printed!"

note = input("Entrez votre moyenne obtenue au bac ")
if note >= 10:
    print "Vous êtes admis"
    if note >= 12 and note < 14:
        print "Mention AB"
    if note >= 14 and note < 16:
        print "Mention B"
    if note >= 16:
        print "Mention TB"
else:
    print "Vous n'êtes pas admis"

Exercices d'application

poids = input("votre poids (kg) ? ")
taille = input("votre taille (m) ? ")
imc = poids / (taille * taille)
print "indice de masse corporelle :", imc

age = input("âge de la personne ? ")
if age > 60:
    print "c'est une personne âgée"
elif age < 15:
    print "c'est un enfant"
else:
    print "c'est un adulte"

adn = input("entrez une séquence d'ADN: ")
if (adn[:3] == "ATG") and ((adn[-3:] == "TAA") 
    or (adn[-3:] == "TAG") or (adn[-3:] == "TGA")):
    print "C'est un gène !"
else:
    print "Ce n'est pas un gène !"

Introduction aux listes

list_name = [item_1, item_2]
empty_list = []

Exemple :

zoo_animals = ["Tigre", "lion", "Singe"]

Accès par index

Comme pour les chaînes, on accède à un élément par son indice (qui commence à 0) :

numbers = [5, 6, 7, 8]
print numbers[0] + numbers[2]   # 5 + 7 = 12
numbers[0] = 9
print numbers[0]                 # 9

Longueur et ajout d'éléments

Une liste n'a pas de longueur fixe : on peut y ajouter des éléments.

letters = ['a', 'b', 'c']
letters.append('d')
print len(letters)   # 4
print letters         # ['a', 'b', 'c', 'd']

Découpage (slicing)

letters = ['a', 'b', 'c', 'd', 'e']
slice = letters[1:3]
print slice           # ['b', 'c']
print letters         # ['a', 'b', 'c', 'd', 'e']

Le slicing fonctionne aussi sur les chaînes :

ch = "Juliette"
print ch[:3]    # "Jul" — les 3 premiers caractères
print ch[3:]    # "iette" — tout sauf les 3 premiers
print ch[:-3]   # "Julie" — tout sauf les 3 derniers
print ch[-3:]   # "tte" — les 3 derniers

Méthodes utiles sur les listes

animals = ["cat", "ant", "bat"]
animals.sort()
# animals vaut maintenant ['ant', 'bat', 'cat']
animals.remove("cat")

Vérifier si un élément est dans une liste

if "Y" in chromosomes:
    print "C'est un garçon !"

Copie de liste

L1 = [5, 3, 1, 2, 4]
L2 = L1          # référence (pas copie)
L3 = L1[:]       # vraie copie
L1.remove(5)
print L1   # [3, 1, 2, 4]
print L2   # [3, 1, 2, 4]  ← suit L1 !
print L3   # [5, 3, 1, 2, 4]  ← copie indépendante

Les boucles

La boucle for

Pour parcourir tous les éléments d'une liste, on utilise une boucle for :

for variable in list_name:
    # instructions

Exemple :

my_list = [1, 9, 3, 8, 5, 7]
for number in my_list:
    print 2 * number

start_list = [5, 3, 1, 2, 4]
square_list = []
for number in start_list:
    square_list.append(number ** 2)
square_list.sort()
print square_list   # [1, 4, 9, 16, 25]

La fonction range

range([debut], fin, [pas]) génère une liste de nombres entiers :

print range(10)        # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print range(4, 10)     # [4, 5, 6, 7, 8, 9]
print range(4, 10, 2)  # [4, 6, 8]

range est très utile pour itérer sur les indices :

adn = "atcacgtta"
for i in range(len(adn)):
    print "la base n°", i, "est", adn[i]

enumerate

La fonction enumerate donne à la fois l'indice et la valeur :

choices = ['pizza', 'pasta', 'salad', 'nachos']
print 'Your choices are:'
for index, item in enumerate(choices):
    print index, item

Sortie :

Your choices are:
0 pizza
1 pasta
2 salad
3 nachos

zip — parcourir plusieurs listes

zip permet de parcourir plusieurs listes en parallèle. La boucle s'arrête à la fin de la liste la plus courte.

list_a = ['V', 9, 17, 15, 19]
list_b = ['A', 4, 8, 10, 30, 40, 50, 80, 90]
for a, b in zip(list_a, list_b):
    print a, b

La boucle while

La boucle while exécute du code tant que la condition est vraie.

count = 0
while count < 5:
    print "Hello, count = ", count
    count = count + 1

L'instruction break

break permet de sortir immédiatement d'une boucle.

from random import randint

random_number = randint(1, 10)
guesses_left = 3
while guesses_left > 0:
    guess = int(raw_input("Your guess: "))
    if guess == random_number:
        print "You win!"
        break
    guesses_left -= 1
else:
    print "You lose!"

Exercices d'application sur les boucles

proteine = "CVAPGPMCAWCDSTAC"
nb_cysteine = 0
for aa in proteine:
    if aa == "C":
        nb_cysteine = nb_cysteine + 1
print "il y a", nb_cysteine, "cystéine(s)"

proteine = "CVAPGPMCAWCDSTAC"
nb_soufre = 0
for aa in proteine:
    if (aa == "C") or (aa == "M"):
        nb_soufre = nb_soufre + 1
print "il y a", nb_soufre, "atomes de soufre"

chromosomes = []
while True:
    n_chromosome = input("Entrez un n° de chromosome : ")
    if n_chromosome == "":
        break
    chromosomes.append(n_chromosome)

if "Y" in chromosomes:
    print "C'est un homme."
else:
    print "C'est une femme."

Les dictionnaires

d = {'key1': 1, 'key2': 2, 'key3': 3}

Exemple :

residents = {'Puffin': 104, 'Sloth': 105, 'Burmese Python': 106}
print residents['Sloth']            # 105
print residents['Burmese Python']   # 106

Ajouter, modifier et supprimer

menu = {}                       # dictionnaire vide
menu['Chicken Alfredo'] = 14.50 # ajout
print menu['Chicken Alfredo']

del menu['Chicken Alfredo']     # suppression
menu['Chicken Alfredo'] = 20    # modification

Dictionnaires de valeurs variées

Un dictionnaire peut contenir des listes, des nombres, des chaînes, etc.

inventaire = {
    'or': 500,
    'pochette': ['silex', 'ficelle', 'pierre'],
    'sac': ['xylo', 'dagger', 'bedroll', 'pain']
}

Parcourir un dictionnaire

Quand on itère sur un dictionnaire, on récupère les clés :

d = {'a': 'apple', 'b': 'berry', 'c': 'cherry'}
for key in d:
    print key + " " + d[key]

Sortie :

a apple
b berry
c cherry

d = {'x': 9, 'y': 10, 'z': 20}
for key in d:
    if d[key] == 10:
        print "On a trouvé un 10 !"

Synthèse

Dans cette leçon, vous avez appris :

• Les variables, qui stockent des valeurs
• Les types de données : numérique, chaîne, booléen
• Les commentaires, qui facilitent la lecture du code
• Les opérations arithmétiques : +, -, *, /, **, %
• Les chaînes de caractères et leurs méthodes (len, lower, upper, str)
• L'importation de modules
• Les comparateurs et opérateurs booléens
• Les structures conditionnelles if, elif, else
• Les listes et leurs méthodes
• Les boucles for et while
• Les dictionnaires

Références

• https://www.anaconda.com/download/
• http://www.programmingforbiologists.org/programming/
• https://www.codecademy.com/