Les variables par l'exemple

• Affectons une valeur à la variable age

1 >>> age = 30
2 >>> age
3 30

• On va ensuite ajouter 10 à la valeur de cette variable

1 >>> age = 30
2 >>> age = age + 10
3 >>> age
4 40

• Il est possible de mettre une variable dans une autre variable.

1 >>> age = 30
2 >>> age2 = age
3 >>> age2
4 30

• On peut mettre à peu près tout ce qu'on veut dans la variable, y compris du texte:

1 >>> age = "J'ai 30 ans"
2 >>> age
3 "J'ai 30 ans"

• Il est possible de concaténer, c'est à dire d'ajouter du texte à du texte:

1 >>> age = age + " et je suis encore jeune!"
2 >>> age
3 "J'ai 30 ans et je suis encore jeune!"

• On peut même multiplier une chaine de caractères.

1 >>> age = "jeune"
2 >>> age * 3
3 'jeunejeunejeune'

• Evidemment, si on essaie de faire des additions avec des variables qui sont des chiffres et d'autres qui sont du texte, l'interpréteur va hurler

1 >>> age = "J'ai 30 ans"
2 >>> age
3 "J'ai 30 ans"
4 >>> age + 1
5 Traceback (most recent call last):
6   File "<stdin>", line 1, in <module>
7 TypeError: cannot concatenate 'str' and 'int' objects

• On remarquera que l'interpréteur est sympa puisqu'il dit ce qui ne va pas: Il ne peut pas concaténer str et int .

• Les listes (ou list / array ) en python sont une variable dans laquelle on peut mettre plusieurs variables.

Créer une liste en python

1  >>> liste = []

Voir le contenu de la liste en l'appelant

1  >>> liste
2  <type 'list'>

Ajouter une valeur à une liste python

1  >>> liste = [1,2,3]
2  >>> liste
3  [1, 2, 3]

Ajouter après la création de la liste

méthode append

1  >>> liste = []
2  >>> liste
3  []
4  >>> liste.append(1)
5  >>> liste
6  [1]
7  >>> liste.append("ok")
8  >>> liste
9  [1, 'ok']

• Il est possible de mélanger dans une même liste des variables de type différent. On peut d'ailleurs mettre une liste dans une liste.

Afficher un item d'une liste

1  >>> liste = ["a","d","m"]
2  >>> liste[0]
3  'a'
4  >>> liste[2]
5  'm'

Modifier une valeur avec son index

1  >>> liste = ["a","d","m"]
2  >>> liste[0]
3  'a'
4  >>> liste[2]
5  'm'
6  >>> liste[2] = "z"
7  >>> liste
8  ['a', 'd', 'z']

Supprimer une entrée avec un index

Fonction del

1  >>> liste = ["a", "b", "c"]
2  >>> del liste[1]
3  >>> liste
4  ['a', 'c']

Supprimer une entrée avec sa valeur

Méthode remove

1  >>> liste = ["a", "b", "c"]
2  >>> liste.remove("a")
3  >>> liste
4  ['b', 'c']

Inverser les valeurs d'une liste

• Inverser les items d'une liste

méthode reverse

1  >>> liste = ["a", "b", "c"]
2  >>> liste.reverse()
3  >>> liste
4  ['c', 'b', 'a']

Compter le nombre d'items d'une liste

• Il est possible de compter le nombre d'items d'une liste avec la fonction len .

1  >>> liste = [1,2,3,5,10]
2  >>> len(liste)
3  5

Compter le nombre d'occurences d'une valeur

Méthode count

1  >>> liste = ["a","a","a","b","c","c"]
2  >>> liste.count("a")
3  3
4  >>> liste.count("c")
5  2

Trouver l'index d'une valeur

méthode index

1  >>> liste = ["a","a","a","b","c","c"]
2  >>> liste.index("b")
3  3

Manipuler une liste

 1  >>> liste = [1, 10, 100, 250, 500]
 2  >>> liste[0]
 3  1
 4  >>> liste[-1] # Cherche la dernière occurence
 5  500
 6  >>> liste[-4:] # Affiche les 4 dernières occurrences
 7  [500, 250, 100, 10]
 8  >>> liste[:] # Affiche toutes les occurences
 9  [1, 10, 100, 250, 500]
10  >>> liste[2:4] = [69, 70]
11  [1, 10, 69, 70, 500]
12  >>> liste[:] = [] # vide la liste
13  []

Boucler sur une liste

• Pour afficher les valeurs d'une liste, on peut utiliser une boucle:

1  >>> liste = ["a","d","m"]
2  >>> for lettre in liste:
3  ...     print lettre
4  ... 
5  a
6  d
7  m

• Pour récupérer l'index, utiliser la fonction enumerate .

1  >>> for lettre in enumerate(liste):
2  ...     print lettre
3  ... 
4  (0, 'a')
5  (1, 'd')
6  (2, 'm')

Les valeurs retournées par la boucle sont des tuples.

Copier une liste

• Beaucoup de débutants font l'erreur de copier une liste de cette manière:

1  >>> x = [1,2,3]
2  >>> y = x

• Or si on change une valeur de la liste y , la liste x sera elle aussi affectée par cette modification:

1  >>> x = [1,2,3]
2  >>> y = x
3  >>> y[0] = 4
4  >>> x
5  [4, 2, 3]

• En fait cette syntaxe permet de travailler sur un même élément nommé différemment
• Alors comment copier une liste qui sera indépendante?

1  >>> x = [1,2,3]
2  >>> y = x[:]
3  >>> y[0] = 9
4  >>> x
5  [1, 2, 3]
6  >>> y
7  [9, 2, 3]

• Pour des données plus complexes, utiliser la fonction deepcopy du module copy

1  >>> import copy
2  >>> x = [[1,2], 2]
3  >>> y = copy.deepcopy(x)
4  >>> y[1] = [1,2,3]
5  >>> x
6  [[1, 2], 2]
7  >>> y
8  [[1, 2], [1, 2, 3]]

Transformer une string en liste

• Transformer une chaine de caractère en liste.

Méthode split

1  >>> ma_chaine = "Olivier:ENGEL:Strasbourg"
2  >>> ma_chaine.split(":")
3  ['Olivier', 'ENGEL', 'Strasbourg']

Transformer une liste en string

Méthode " join "

1  >>> liste = ["Olivier","ENGEL","Strasbourg"]
2  >>> ":".join(liste)
3  'Olivier:ENGEL:Strasbourg'

Trouver un item dans une liste

• Pour savoir si un élément est dans une liste, utiliser le mot clé in de cette manière:

1  >>> liste = [1,2,3,5,10]
2  >>> 3 in liste
3  True
4  >>> 11 in liste
5  False

La fonction range

• La fonction range génère une liste composée d'une simple suite arithmétique.

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

Agrandir une liste par une liste

• Pour mettre bout à bout deux listes, utiliser la méthode extend

1  >>> x = [1, 2, 3, 4]
2  >>> y = [4, 5, 1, 0]
3  >>> x.extend(y)
4  >>> print x
5  [1, 2, 3, 4, 4, 5, 1, 0]

Permutations

• La permutation d'un ensemble d'éléments est une liste de tous les cas possibles.
• Si on besoin de cette fonctionnalité, inutile de réinventer la roue, itertools

1  >>> from itertools import permutations
2  >>> list(permutations(['a', 'b', 'c']))
3  [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]

Permutation d'une liste de liste

• Afficher tous les cas possibles d'une liste elle-même composée de liste?
• Outil product de itertools :

1  >>> from itertools import product
2  >>> list(product(['a', 'b'], ['c', 'd']))
3  [('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]

Astuces

• Afficher les 2 premiers éléments d'une liste

1  >>> liste = [1,2,3,4,5]
2  >>> liste[:2]
3  [1, 2]

• Afficher le dernier item d'une liste:

1  >>> liste = [1, 2, 3, 4, 5, 6]
2  >>> liste[-1]
3  6

• Afficher le 3ème élément en partant de la fin:

1  >>> liste = [1, 2, 3, 4, 5, 6]
2  >>> liste[-3]
3  4

• Afficher les 3 derniers éléments d'une liste:

1  >>> liste = [1, 2, 3, 4, 5, 6]
2  >>> liste[-3:]
3  [4, 5, 6]

• Additionner deux listes pour les combiner ensemble en utilisant l'opérateur + :

1  >>> x = [1, 2, 3]
2  >>> y = [4, 5, 6]
3  >>> x + y
4  [1, 2, 3, 4, 5, 6]

• Mutiplier une liste:

1  >>> x = [1, 2]
2  >>> x*5
3  [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

• Utile pour initialiser une liste:

1  >>> [0] * 5
2  [0, 0, 0, 0, 0]

Méthodes de manipulation de listes

• Un tuple est une liste qui ne peut plus être modifiée.

Créer un tuple

1  >>> mon_tuple = ()

Ajouter une valeur à un tuple

• Créer un tuple avec des valeurs

1  >>> mon_tuple = (1, "ok", "olivier")

• Les parenthèses ne sont pas obligatoires mais facilite la lisibilité du code (rappelons que la force de python est sa simplicité de lecture):

1  >>> mon_tuple = 1, 2, 3
2  >>> type(mon_tuple)
3  <type 'tuple'>

• Lorsqu'on créé un tuple avec une seule valeur, ne pas oublier d'y ajouter une virgule, sinon ce n'est pas un tuple.

1  >>> mon_tuple = ("ok")
2  >>> type(mon_tuple)
3  <type 'str'>
4  >>> mon_tuple = ("ok",)
5  >>> type(mon_tuple)
6  <type 'tuple'>

Afficher une valeur d'un tuple

• Le tuple est une sorte de liste, on peut donc utiliser la même syntaxe pour lire les données du tuple.

1  >>> mon_tuple[0]
2  1

• Et évidemment si on essaie de changer la valeur d'un index, l'interpreteur nous insulte copieusement:

1  >>> mon_tuple[1] = "ok"
2  Traceback (most recent call last):
3   File "<stdin>", line 1, in <module>
4  TypeError: 'tuple' object does not support item assignment

A quoi sert un tuple alors?

• Le tuple permet une affectation multiple:

1  >>> v1, v2 = 11, 22
2  >>> v1
3  11
4  >>> v2
5  22

• Il permet également de renvoyer plusieurs valeurs lors d'un appel d'une fonction:

1  >>> def donne_moi_ton_nom():
2  ...     return "olivier", "engel"
3  ... 
4  >>> donne_moi_ton_nom()
5  ('olivier', 'engel')

• On utilisera un tuple pour définir des sortes de constantes qui n'ont donc pas vocation à changer.

• Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index , on utilise des clés alphanumériques.

Créer un dictionnaire python

• Initialiser un dictionnaire:

1  >>> a = {}

• ou

1  >>> a = dict()

Ajouter des valeurs dans un dictionnaire python

• Il faut indiquer une clé ainsi qu'une valeur:

1  >>> a = {}
2  >>> a["nom"] = "Wayne"
3  >>> a["prenom"] = "Bruce"
4  >>> a
5  {'nom': 'Wayne', 'prenom': 'Bruce'}

• On peut utiliser des clés numériques comme dans la logique des listes .
• Comment récupérer une valeur dans un dictionnaire python?
• La méthode get permet de récupérer une valeur dans un dictionnaire et si la clé est introuvable, on peut donner une valeur à retourner par défaut:

1  >>> data = {"name": "Wayne", "age": 45}
2  >>> data.get("name")
3  'Wayne'
4  >>> data.get("adresse", "Adresse inconnue")
5  'Adresse inconnue'

Vérifier la présence d'une clé dans un dictionnaire python

• Utiliser la méthode haskey pour vérifier la présence d'une clé

1  >>> a.has_key("nom")
2  True

Supprimer une entrée dans un dictionnaire python

• Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes:

1  >>> del a["nom"]
2  >>> a
3  {'prenom': 'Bruce'}

Récupérer les clés d'un dictionnaire python par une boucle

• Pour récupérer les clés on utilise la méthode keys .

1  >>> fiche = {"nom":"Wayne", "prenom":"Bruce"}
2  >>> for cle in fiche.keys():
3  ...     print cle
4  ... 
5  nom
6  prenom

Récupérer les valeurs d'un dictionnaire python par une boucle

• Méthode values

1  >>> fiche = {"nom":"Wayne", "prenom":"Bruce"}
2  >>> for valeur in fiche.values():
3  ...     print valeur
4  ... 
5  Wayne
6  Bruce

Récupérer les clés et les valeurs d'un dictionnaire python par une boucle

• Pour récupérer les clés et les valeurs en même temps, on utilise la méthode items qui retourne un tuple .

1  >>> fiche = {"nom":"Wayne","prenom":"Bruce"}
2  >>> for cle,valeur in fiche.items():
3  ...     print cle, valeur
4  ... 
5  nom Wayne
6  prenom Bruce

Utiliser des tuples comme clé dans un dictionnaire python

• Une des forces de python est la combinaison tuple/dictionnaire qui fait des merveilles dans certains cas comme lors de l'utilisation de coordonnées.

1  >>> b = {}
2  >>> b[(32)]=12
3  >>> b[(45)]=13
4  >>> b
5  {(4, 5): 13, (3, 2): 12}

Créer une copie indépendante d'un dictionnaire python

• Comme pour toute variable, on ne peut pas copier un dictionnaire en faisant dic1 = dic2

1  >>> d = {"k1":"Bruce", "k2":"Wayne"}
2  >>> e = d
3  >>> d["k1"] = "XXX"
4  >>> e
5  {'k2': 'Wayne', 'k1': 'XXX'}

• Pour créer une copie indépendante, on peut utiliser la méthode copy

1  >>> d = {"k1":"Bruce", "k2":"Wayne"}
2  >>> e = d.copy()
3  >>> d["k1"] = "XXX"
4  >>> e
5  {'k2': 'Wayne', 'k1': 'Bruce'}

Fusionner des dictionnaires python

• La méthode update permet de fusionner deux dictionaires .

1  >>> a = {'nom': 'Wayne'}
2  >>> b = {'prenom': 'bruce'}
3  >>> a.update(b)
4  >>> print(a)
5  {'nom': 'Wayne', 'prenom': 'Bruce'}

Les fonctions

• Une fonction (ou function ) est une suite d'instructions que l'on peut appeler avec un nom.

Première fonction

• Créons une fonction qui nous retournera un âge:

1  >>> def indique_mon_age():
2  ...     return 30;
3  ... 
4  >>> indique_mon_age()
5  30

• On ne peut pas copier coller ce code, on doit entrer chaque ligne à la main et appuyer sur entrée pour retourner à la ligne. Les 3 chevrons et les 3 points sont affichés par l'interpréteur python.
• Tout d'abord pour indiquer à l'interpréteur qu'on veut créer une fonction , on utilisera le mot clé def suivi d'un nom puis de parenthèses et ensuite d'un double point.
• On remarque également qu'il y a un espace entre les 3 points et le mot clé "return", il s'agit d'une indentation , c'est à dire un espace qui améliore non seulement la lecture de la fonction mais qui indique que nous sommes toujours dans la fonction. Lorsque l'action demandée n'est plus dans la fonction, il ne faut plus indenter le texte. Pour indenter du texte, on doit appuyer sur la touche TAB du clavier -ou dans d'autres cas créer 4 espaces manuellement-.

Les paramètres

• Créons une autre fonction:

1 >>> def augmente_moi(a):
2 ...     return augmente_moi + 2
3 ... 
4 >>> augmente_moi(1)
5 3

• Cette fonction incrémente de 2 une valeur que l'on passe en paramètre.
• Il est d'ailleurs possible d'utiliser plusieurs paramètres:

1  >>> def augmente_moi(a, b):
2  ...     return 30 + a + b
3  ... 
4  >>> augmente_moi(1, 2)
5  33

• Un paramètre est obligatoire
• Lorsqu'on indique des paramètres à une fonction, ces derniers doivent impérativement être renseignés sans quoi une erreur apparaîtra.

1  >>> def augmente_moi(a, b):
2  ...     return 30 + a + b
3  ...
4  >>> augmente_moi(1)
5  Traceback (most recent call last):
6   File "<stdin>", line 1, in <module>
7  TypeError: augmente_moi() takes exactly 2 arguments (1 given)

• L'opérateur splat : * est très souvent utilisé en python.

def ma_function(*var)
def ma_function(**var)
ma_function(*var)
ma_function(**var)

• Une liste en paramètre
• On peut récupérer les valeurs renseignées via une liste:

1 >>> def augmente_moi(*param):
2 ...     return param[0] + param[1] + param[2]
3 ... 
4 >>> augmente_moi(1, 2, 3)
5 6
6 >>> augmente_moi(10, 20, 30)
7 60

• Rendre obligatoire uniquement certains paramètres avec une liste.
• Si on désire rendre obligatoire uniquement certains paramètres, utiliser la syntaxe suivante:

1 >>> def ma_fiche(prenom, nom, *reste):
2 ...     return prenom + " " + nom 
3 ... 
4 >>> ma_fiche("olivier","engel")
5 'olivier engel'

• On remarque que le paramètre " reste " est précédé d'une étoile * .
• Utiliser un dictionnaire pour les paramètres
• On peut utiliser un dictionnaire en paramètres pour cela on doit ajouter une double étoile: **

1 >>> def ma_fiche(**parametres):
2 ...     return parametres["prenom"]
3 ...
4 >>> ma_fiche(prenom="olivier")
5 'olivier'

Utilisation de splat liste au niveau des appels de fonctions

• Reprenons l'exemple de la fonction augmente_moi :

1 >>> def augmente_moi(*param):
2 ...     return param[0] + param[1] + param[2]
3 ...

• Nous avons vu qu'il était possible de faire ceci:

1 >>> augmente_moi(1, 2, 3)
2 6

• L'utilisation de l'étoile permet de passer par une liste:

1 >>> data = [1, 2, 3]
2 >>> augmente_moi(*data)
3 6

• Utilisation de splat dictionnaire au niveau des appels de fonctions.
• Prenons l'exemple de cette fonction:

1 >>> def test(firstname="", lastname=""):
2 ...     return "{} {}" .format(firstname, lastname)

• Créons notre dictionnaire:

1 >>> data = {'firstname':'olivier', 'lastname':'engel'}

• Et envoyons notre variable avec une étoile *

1 >>> test(*data)
2 'lastname firstname'

• Puis avec deux étoiles **

1 >>> test(**data)
2 'olivier engel'

Portée des variables (variable globale et variable locale)

Une variable déclarée à la racine d'un module est visible dans tout ce module. On parle alors de variable globale .

1 >>> x = "hello"
2 >>> def test():
3 ...     print x
4 ... 
5 >>> test()
6 hello

Et une variable déclarée dans une fonction ne sera visible que dans cette fonction. On parle alors de variable locale .

1 >>> x = False
2 >>> def test():
3 ...     x = "hello"
4 ... 
5 >>> test()
6 >>> x
7 False

Les fonctions natives

1  >>> abs(-1)
2  1

1  >>> liste = [True,True,True,1]
2  >>> all(liste)
3  True

1  >>> liste = [True,False, True]
2  >>> any(liste)
3  True

1  >>> bin(101)
2  '0b1100101'

1  >>> callable("A")
2  False
3  >>> callable(int)
4  True

1  >>> "oLIviER".capitalize()
2  'Olivier'

1  >>> import random
2  >>> random.choice([1,2,3,4,5])
3  3
4  >>> random.choice([1,2,3,4,5])
5  2

1  >>> "olivier".count("i")
2  2

1  >>> dir(int)
2  ['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']

1  >>> a = "olivier"
2  >>> a.endswith("r")
3  True
4  >>> a.endswith("er")
5  True
6  >>> a.endswith("é")
7  False

1  >>> v = 101
2  >>> eval('v+1')
3  102

1  >>> "olivier".find("i")
2  2

 1  >>> help(int)
 2  Help on class int in module __builtin__:
 3  class int(object)
 4   |  int(x=0) -> int or long
 5   |  int(x, base=10) -> int or long
 6   |  
 7   |  Convert a number or string to an integer, or return 0 if no arguments
 8   |  are given.  If x is floating point, the conversion truncates towards zero.
 9   |  If x is outside the integer range, the function returns a long instead.
10   |  
11   |  If x is not a number or if base is given, then x must be a string or
12   |  Unicode object representing an integer literal in the given base.  The
13   |  literal can be preceded by '+' or '-' and be surrounded by whitespace.
14   |  The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
15   |  interpret the base from the string as an integer literal.
16   |  >>> int('0b100', base=0)
17   |  4

1  >>> hex(16)
2  '0x10'

 1  >>> "25".isalnum()
 2  True
 3  >>> "25b".isalnum()
 4  True
 5  >>> "25bé".isalnum()
 6  True
 7  >>> "25bé@".isalnum()
 8  False
 9  >>> "-".isalnum()
10  False
11  >>> "_".isalnum()
12  False
13  >>> "".isalnum()
14  False

 1  >>> "x".isalpha()
 2  True
 3  >>> "-".isalpha()
 4  False
 5  >>> "12".isalpha()
 6  False
 7  >>> "jean-claude".isalpha()
 8  False
 9  >>> "jean claude".isalpha()
10  False
11  >>> "élise".isalpha()
12  True

 1  >>> "1".isdigit()
 2  True
 3  >>> "1.5".isdigit()
 4  False
 5  >>> "1,5".isdigit()
 6  False
 7  >>> "3b".isdigit()
 8  False
 9  >>> " ".isdigit()
10  False

1  >>> "olivier".islower()
2  True
3  >>> "Olivier".islower()
4  False

1  >>> " ".isspace()
2  True
3  >>> "jean louis".isspace()
4  False
5  >>> "    ".isspace()
6  True

1  >>> "Titre".istitle()
2  True
3  >>> "TitrE".istitle()
4  False
5  >>> "Titre de mon site".istitle()
6  False
7  >>> "Titre De Mon Site".istitle()
8  True

1  >>> "OLIVIER".isupper()
2  True
3  >>> "Olivier".isupper()
4  False
5  >>> "OlivieR".isupper()
6  False

1  >>> ":".join(["olivier", "engel"])
2  'olivier:engel'

1  >>> len([1,2,3])
2  3
3  >>> len("olivier")
4  7

1  >>> locals()
2  {'a': 12, '__builtins__': , '__package__': None, 'i': 20, 'v': 101, 'liste': [True, False, True], '__name__': '__main__', '__doc__': None}

1  >>> "OLIVIER".lower()
2  'olivier'

1  >>> def add_one(x):
2  ...     return x + 1
3  ... 
4  >>> map(add_one, [1,2,3])
5  [2, 3, 4]

1  >>> max([1,3,2,6,99,1])
2  99
3  >>> max(1,4,6,12,1)
4  12

1  >>> import random
2  >>> random.randint(1,11)
3  5

1  >>> import random
2  >>> random.random()
3  0.9563522652738929

1  >>> "olivier".replace("i", "a")
2  'olavaer'

1  >>> x = [1,4,7]
2  >>> x.reverse()
3  >>> x
4  [7, 4, 1]

1  >>> list(reversed([1,2,3,4]))
2  [4, 3, 2, 1]

 1  >>> round(1)
 2  1.0
 3  >>> round(1.2)
 4  1.0
 5  >>> round(1.5)
 6  2.0
 7  >>> round(1.7)
 8  2.0
 9  >>> round(-1.7)
10  -2.0
11  >>> round(-1.2)
12  -1.0

1  >>> import random
2  >>> x = [1,2,3,4,5]
3  >>> random.shuffle(x)
4  >>> x
5  [2, 5, 4, 1, 3]

 1  >>> "olivier".startswith("ol")
 2  True
 3  >>> "olivier".startswith(("ol", "eng"))
 4  True
 5  >>> "olivier".startswith(("xxx", "eng"))
 6  False
 7  >>> "olivier".startswith("OL")
 8  False
 9  >>> "olivier".startswith("ol")
10  True

1  >>> l = [5,1,4,2,10]
2  >>> l.sort()
3  >>> l
4  [1, 2, 4, 5, 10]

1  >>> sorted([3,2,12,1])
2  [1, 2, 3, 12]

1  >>> "olivier:engel".split(":")
2  ['olivier', 'engel']

 1  >>> "olivier\n\n\engel\n\ndéveloppeur".splitlines()
 2  ['olivier', '', '\\engel', '', 'développeur']
 3  >>> "olivier\nengel\ndéveloppeur".splitlines()
 4  ['olivier', 'engel', 'développeur']
 5  >>> "olivier\n\rengel\n\rdéveloppeur".splitlines()
 6  ['olivier', '', 'engel', '', 'développeur']
 7  >>> "olivier\r\nengel\r\ndéveloppeur".splitlines()
 8  ['olivier', 'engel', 'développeur']
 9  >>> "olivier\r\nengel\r\n\r\ndéveloppeur".splitlines()
10  ['olivier', 'engel', '', 'développeur']
11  >>> "olivier\r\nengel\r\n\r\ndéveloppeur".splitlines(True)
12  ['olivier\r\n', 'engel\r\n', '\r\n', 'développeur']

1  >>> sum([1,2,3])
2  6

1  >>> "Ceci est un titre".title()
2  'Ceci Est Un Titre'

1  >>> "olivier".upper()
2  'OLIVIER'

1  >>> a = ["olivier", "bruce", "john"]
2  >>> b = ["engel", "wayne", "Wayne"]
3  >>> zip(a,b)
4  [('olivier', 'engel'), ('bruce', 'wayne'), ('john', 'Wayne')]

Procédure et fonctions

• Une fonction n'est pas obligée de renvoyer une valeur, on parlera alors dans ce cas plutôt de procédure .