Contents

Variables et types

Pour écrire un programme, il faut utiliser des variables. Une variable consiste à associer une information à un nom. On peut ainsi manipuler ce nom et l’utiliser dans diverses situations. Par exemple, on peut attribuer le réel \(10\) à un_reel. Nous pouvons désormais utiliser la variable un_reel pour des opérations.

Il existe plusieurs types de variables : les types numériques, les chaines de charactères, les types modifiables ou mutable et les autres types d’objets souvent utiliser en programmation.

Une fonction utile à retenir est la fonction type() qui retourne une variable de type type. Des exemples seront donnés dans la suite de ce chapitre. Le chapitre 2 développe cette notion de fonction.

Les éléments non mutables

Un éléments non mutable est un élément que l’on ne peut pas modifier.

Les types numériques

Il existe plusieurs types numérique :

  • int : entier compris entre \(-2 147 483 648\) et \(2 147 483 647\)

  • long : Entier long compris entre \(-\infty\) et \(-2 147 483 648\) ou entre \(2 147 483 648\) et \(+\infty\)

  • float : Nombre à virgule flottante float, valeur spécifiée avec un point dans le programme

  • complex : Nombre complexe

Les entiers

x = 5
y = -3
print(type(x))

<class 'int'>

Pour afficher dans la console le contenu de notre variable x contenant la chaîne de caractères, on fait appel à la fonction print() :

print(x)

5

Nombre à virgule flottante

Les nombes à virgule flottante (floats) représentent les nombres réels. Ils sont écrits à l’aide d’un point.

x = 5.25
print(type(x))
x = 3.2E12
print(x)

<class 'float'>
3200000000000.0

Les complexes

Python permet de manipuler des nombres complèxes \(z=a+ib\), où \(a\) et \(b\) sont des nombres de type float, et tel que \(i^2=(-i)^2=1\).

En python, l’unité imaginaire \(i\) est dénotée par la lettre j.

x = 5j + 2
print(type(x))
x = complex(2,5)

<class 'complex'>

On peut aussi retrouver la partie imaginaire ou réelle de x à l’aide de fonctions:

print(x.real)
print(x.imag)

2.0
5.0

Changement de type

Il est possible de passer de l’un à lautre type ou de forcer une variable numérique a être d’un certain type. La conversion d’un entier se fait avec la fonction int(), d’un flottant avec la fonction float() et d’un complexe avec la fonction complex()

x = 2.0
print(type(x))
x = int(x)
print(type(x))
y = 2
print(type(y))
y = float(y)
print(type(y))

<class 'float'>
<class 'int'>
<class 'int'>
<class 'float'>

Les chaines de caractères

Présentation

Une chaîne de caractères (string en anglais), est une suite de caractères quelque soit la nature des caractères qui la compose. Les chaînes de caractères sont repérées à l’aide de guillemets simples ou doubles.

s = 'J\'aime les pizzas'
print(s)
print(type(s))

J'aime les pizzas
<class 'str'>

s = "J'aime 5 pizzas, le champagne \net Patrick Balkany"
print(s)
print(type(s))
print(len(s))

J'aime 5 pizzas, le champagne 
et Patrick Balkany
<class 'str'>
49

Remarques:

  • Si la chaine est commencée par un guillemet simple, il faut utiliser \ pour utilier le guillemet simple dans la chaine de caractère

  • On peut mélanger les types de chractère

  • Le retour à la ligne se faire par l’utilisation de \n

  • Pour récupérer la longueur d’une chaîne de caractères, Python propose la fonction len()

  • Le caractère \ est le caractère d’échappement. Il permet d’afficher d’appeler à plusieurs méchanisme de mise en page pour une sortie propre :

Code

Description

Code

Description

\n

Nouvelle ligne

\r

Retour à la ligne

\t

Tabulation

\b

Retour arrière

\\

Caractère \

\%

Caractère %

Voir https://docs.python.org/3/reference/lexical_analysis.html

Manipulation d’une chaîne de caractères

La concaténation

La concaténation consiste à rassembler deux chaines de caractères :

s1 = 'J\'ai eu mon semestre'
s2 = ' au rattrapage'
print(s1 + s2)

J'ai eu mon semestre au rattrapage

On peut aussi répéter une même chaine de caractère à l’aide de l’opérateur * :

s1 = 'J\'ai eu mon semestre ! '
print(s1 * 3)

J'ai eu mon semestre ! J'ai eu mon semestre ! J'ai eu mon semestre !

Il est également possible d’ajouter à une chaîne de caractères le contenu d’une variable. Il s’agit de de l’outil python printf-style. Il permet de former une chaine de caractères à l’aide plusieurs types d’informations en évitant de de voir les transformer au préalable puis de les concatener. Il suit le forma suivant :

".... %c1  ....  %c2 " % (v1,v2)

c1 est un code qui indique le format dans lequel la variable v1 devra être transcrite. Voici une liste des différents codes: https://docs.python.org/3/library/stdtypes.html#old-string-formatting Example concret :

x = 2.0
y = 3
s = "pizzas"
res = "J'ai commandé %1.2f %s, on m'a livré %d pizzas" % (x, s, y)
print(res)

res = "J'ai commandé " + str(x) + " " + s + ", on m'a livré " + str(y) + " pizzas" 
print(res)

J'ai commandé 2.00 pizzas, on m'a livré 3 pizzas
J'ai commandé 2.0 pizzas, on m'a livré 3 pizzas

La méthode format fait à peu prêt la même chose mais propose un peu plus d’options pour formatter le texte. Il suffit d’utiliser les accolades {} comme des codes qu’elle remplace avec les valeurs passée en argument.

s = 'j\'aime vraiment la {}'
x = 'pizza'
print(s.format(x))
x = 'glace'
print(s.format(x))

j'aime vraiment la pizza
j'aime vraiment la glace

exterieur = 2
local = 0
print('Résultat du match : locaux {}, exterieurs {}'.format(local,exterieur))

Résultat du match : locaux 0, exterieurs 2
Indexation et extraction

Les chaînes de caractères peuvent être indexées. Cela signifie que chaque caractère possède un indice. L’indexation commence à \(0\) jusqu’à la longueur de la chaine moins un.

Pour obtenir le ie caractère d’une chaîne, on utilise des crochets.

Les exemples ci-dessous :

  • affiche le 4ème caractère de la chaine s

  • affiche du 2ème au 4ème caractère

  • affiche le 2ème caractère en partant de la fin

  • affiche du 1er au 2ème caractère

  • affiche la toute la chaine en partant de la fin (du 1ere caractère, jusqu’à la fin de la chaîne, par pas de -1)

s = s.format(x)
print(s[5])
print(s[1:5])
print(s[-2])
print(s[:2])
print(s[::-1])

e
'aim
c
j'
ecalg al tnemiarv emia'j
Quelques méthodes

Une chaine de caractère est en fait un défini comme un objet sous python. Un objet est une entité comprenant plein de méthodes. On les appelle en ajoutant un point (.) après le nom de l’objet et en ajoutant le nom de la méthode que l’on souhaite utiliser.

Par exemple, la méthode upper() permet de passer toute la chaine en majuscule. On peut trouver la liste des méthode sur le lien suivant : https://docs.python.org/3/library/stdtypes.html#string-methods

s = "C'est la grève générale"
print(s.count("grève"))
print(s.upper())
print(s.find("la"))
print(x.find("ertgetet"))
print(s.split(" "))

1
C'EST LA GRÈVE GÉNÉRALE
6
-1
["C'est", 'la', 'grève', 'générale']

Exercice

Remarque

  1. Créer deux variables nommées a et b afin qu’elles contiennent respectivement les chaînes de caractères suivantes : 23 à 0 et C'est la piquette, Jack!.

  2. Afficher le nombre de caractères de a, puis de b.

  3. Concaténer a et b dans une seule chaîne de caractères, en ajoutant une virgule comme caractère de séparation.

  4. Même question en choisissant une séparation permettant un retour à la ligne entre les deux phrases.

  5. À l’aide de la méthode appropriée, mettre en majuscules a et b.

  6. À l’aide de la méthode appropriée, mettre en minuscules a et b.

  7. Extraire le mot la et Jack de la chaîne b, en utilisant les indices.

  8. Rechercher si la sous-chaîne piqu est présente dans b, puis faire de même avec la sous-chaîne mauvais.

  9. Retourner la position (indice) du premier caractère a retrouvé dans la chaîne b, puis essayer avec le caractère w.

  10. Remplacer les occurrences du motif a par le motif Z dans la sous-chaîne b.

  11. Séparer la chaîne b en utilisant la virgule comme séparateur de sous-chaînes.

  12. (Bonus) Retirer tous les caractères de ponctuation de la chaîne b, puis utiliser une méthode appropriée pour retirer les caractères blancs en début et fin de chaîne. (Utiliser la librairie regex).

Booléens

Les booléens sont le résultat d’opérations logiques et ont deux valeurs possibles : True ou False. Il est nommé ainsi d’après George Boole, fondateur de l’algèbre de Boole son nom.

True est équivaut à 1 et False à 0.

x = True
y = False
print(x, y)

True False

x = True + True
print(x)

2

On se servira beaucoup des Booléens pour mettre de conditions. Par exemple :

note_marc = 9
note_isabelle = 8
valide = note_marc > 9
print('Martin a validé son année : {}'.format(valide))
print('Martin est Isabelle redoublent : {} '.format(note_marc < 10 and note_isabelle <10 ))

Martin a validé son année : False
Martin est Isabelle redoublent : True

Objet vide

L’objet vide, communément appelé null, possède un équivalent en Python : None. Pour l’assigner à une variable, il faut faire attention à la casse :

x = None
print(x)

None

Les éléments mutables

Les listes

Définition

Les listes s’écrivent entre [ ] et contiennent 0,1 ou beaucoup d’éléments. Chaque élément est séparé par une virgule. Elles sont très utiles lorsqu’il faut effectuer des ittérations. Nous verrons cela par la suite.

Pour faire appel aux élements d’une liste, on donne leur position dans la liste :

une_liste = [1,2,3,4]
une_autre_liste = ['hey','ho']
une_autre_liste_oui = ['hey',1]

print(type(une_liste))
print(une_liste)
print(une_autre_liste[0])
print("La longueur de ma 1ère liste est de", len(une_liste))
print(une_liste[::2])

<class 'list'>
[1, 2, 3, 4]
hey
La longueur de ma 1ère liste est de 4
[1, 3]

Une liste peut contenir des listes :

une_liste_de_liste = [une_liste, une_autre_liste]
print(une_liste_de_liste)
print(une_liste_de_liste[1][1])
print(une_liste_de_liste[0][1])
print(une_liste_de_liste[1][3])

[[1, 2, 3, 4], ['hey', 'ho']]
ho
2

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-21-85ab4bb3ae01> in <module>
      3 print(une_liste_de_liste[1][1])
      4 print(une_liste_de_liste[0][1])
----> 5 print(une_liste_de_liste[1][3])

IndexError: list index out of range

Remplacement

Pour modifier un élément dans une liste :

une_liste[0] = 5 # On modifie le 1er élément
print(une_liste)
une_liste = une_autre_liste*2 # On modifie tous les éléments de la liste
print(une_liste)
s = 'hey'
s[0] = 'y'

[5, 2, 3, 4]
['hey', 'ho', 'hey', 'ho']

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-72-09315c9943f8> in <module>
      4 print(une_liste)
      5 s = 'hey'
----> 6 s[0] = 'y'

TypeError: 'str' object does not support item assignment

Les méthodes

Une liste, comme une string, est un objet et possède des méthodes. Voici quelques une qui peuvent être utiles :

une_liste.append('hey')
print(une_liste)
une_liste.extend(une_autre_liste)
print(une_liste)
une_liste.remove('hey')
print(une_liste)
une_liste[0:2] = []
print(une_liste)
print('hey' in une_liste)

['hey', 'ho', 'hey', 'ho', 'hey']
['hey', 'ho', 'hey', 'ho', 'hey', 'hey', 'ho']
['ho', 'hey', 'ho', 'hey', 'hey', 'ho']
['ho', 'hey', 'hey', 'ho']
True

help(une_liste)

Help on list object:

class list(object)
 |  list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(self, /)
 |      Return a reverse iterator over the list.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(self, /)
 |      Return the size of the list in memory, in bytes.
 |  
 |  append(self, object, /)
 |      Append object to the end of the list.
 |  
 |  clear(self, /)
 |      Remove all items from list.
 |  
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
 |  
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  insert(self, index, object, /)
 |      Insert object before index.
 |  
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
 |      
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |  
 |  sort(self, /, *, key=None, reverse=False)
 |      Stable sort *IN PLACE*.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

Attention, il y a des trucs un peu étrange de prime abord mais cohérents:

une_liste = [1,2,3]
une_autre_liste = une_liste
print(une_liste)
print(une_autre_liste)
une_liste[0] = 20
print(une_autre_liste)
une_autre_liste = list(une_liste)
print(une_autre_liste)
une_liste[0] = 1
print(une_liste)
print(une_autre_liste)

[1, 2, 3]
[1, 2, 3]
[20, 2, 3]
[20, 2, 3]
[1, 2, 3]
[20, 2, 3]

Les dictionnaires

Un dictionnaire est composé d’une clé et d’une valeur. Format d’un dictionnaire : {Clé : valeur}

nb_grevistes = { 'Paris' : 20 , 'Marseille' : 20000000}
print(nb_grevistes)
print(type(nb_grevistes))
print(nb_grevistes["Marseille"])

{'Paris': 20, 'Marseille': 20000000}
<class 'dict'>
20000000

On peut tester la présence d’une clef dans le dictionnaire :

print("Lens" in nb_grevistes)

False

L’extraction de valeurs peut aussi se faire avec get(), qui retourne une valeur None si la clé n’existe pas :

print(nb_grevistes.get("Lens"))
print(nb_grevistes.get("Marseille"))

None
20000000

On peut aussi extraire toutes les clefs ou toutes les valeurs :

clefs = nb_grevistes.keys()
print(clefs)
val = nb_grevistes.values()
print(val)

dict_keys(['Paris', 'Marseille'])
dict_values([20, 20000000])

Finalement, une méthodes bien sympa :

  File "<ipython-input-80-004e7960a159>", line 1
    Finalement, une méthodes bien sympa :
                           ^
SyntaxError: invalid syntax

it = nb_grevistes.items()
print(it)

dict_items([('Paris', 20), ('Marseille', 20000000)])

Si il y a eu plusieurs manif, on peut ajouter l’information dans le dictionnaire :

nb_grevistes["Marseille"] = [20000,200000000, 30000000000000] 
print(nb_grevistes)

{'Paris': 20, 'Marseille': [20000, 200000000, 30000000000000]}

ou une ville :

nb_grevistes["Lille"] = 10000
print(nb_grevistes)

{'Paris': 20, 'Marseille': [20000, 200000000, 30000000000000], 'Lille': 10000}

Exercices

1

  1. Écrire un programme, qui définit 3 variables de type texte, de type nombre entier et de type nombre décimal. Affichez leur type.

  2. Affectez les variables par les valeurs 6.892 et 19.7.

    1. Calculez et affichez la valeur de la vitesse

    2. Améliorez l’affichage en imposant un chiffre après le point décimal

  3. 1 euro vaut environ 1.345 dollar. Ecrivez un programme permettant de calculer combien vaut 1250 euros.

  4. Écrire un programme, qui donne la mesure l’hypothénuse d’un triangle rectangle sachant que l’utilisateur rentre le côté opposé et le côté adjacent d’un triangle rectangle. Pour demander de rentrer une information, on utilise la fonction input() après l’avoir importée : from math import *

  5. Calculez votre moyenne sur le semestre

2

  1. Créer un dictionnaire nommé biblio, comprenant les couples clés-valeurs suivants :

    1. clé : id, valeur : 1,

    2. clé : auteur, valeur : une liste dans laquelle sont renseignés le nom et le prénom Romain,Gary.

    3. clé : date, valeur : 1960

  2. Ajouter le couple suivant au dictionnaire biblio : clé : titre, valeur : La promesse de l'aube.

  3. Rechercher s’il existe une entrée dont la clé vaut auteur dans le dictionnaire biblio.

  4. Modifier la valeur de l’entrée auteur, pour proposer une nouvelle liste : Emile et Ajar.

3

  1. Créer une list qui va de 5 à 20, puis :

    1. triez et affichez la liste

    2. ajoutez l’élément 4 à la liste

    3. affichez l’indice de l’élément 2

Python pour économistes Algorithmie (un peu)