About Python, variable types and script execution. For interactive reading and executing code blocks 
and find b01-pybase.ipynb, or install Python and JupyterLab locally.
Watch this section as a video
Watch this section as a video on the @Hydro-Morphodynamics channel on YouTube.
Charger l’environnement Python¶
These pages are written with JupyterLab 
. For the best learning experience make sure to read about Environnements de développement intégrés before starting this tutorial.
Les premières lignes de code¶
Les exemples des premières étapes tournent autour de la crème glacée pour illustrer l’utilité de simples extraits de code. Si vous n’aimez pas la crème glacée, remplacez-la par votre catégorie de choses préférée.
En fin de compte, vous êtes prêt à obtenir la toute première réponse (sortie) de la console Python. Commencez par un simple appel de la fonction print en entrant :
print("This is output from the digital ice cream printer.")This is output from the digital ice cream printer.
Rappelez-vous que la commande print, comme toutes les autres commandes Python qui suivront, peut être exécutée dans une console Python (par exemple, Conda Prompt sur Windows ou Terminal sur Linux) ou dans votre IDE préféré. En outre, nous pouvons écrire la commande print dans un fichier Python se terminant par .py (par exemple, icecream_tutorial.py) et exécuter le fichier. Par exemple, dans PyCharm:
Élargir la branche du projet (si ce n’est pas encore fait : à gauche de la fenêtre)
Faites un clic droit dans le dossier du projet, sélectionnez
New>Python Fileet nommez le nouveau fichier Python (.py) (par exemple,icecream_tutorial.py).Copiez le code
print("...")ci-dessus dans le nouveau fichier Python et enregistrez-le.Faites un clic droit dans le fichier Python, puis
Run icecream_tutorial.py(autrement: appuyez surCtrl+Shift+F10clés).Maintenant, la console Python doit apparaître en bas de la fenêtre et elle va imprimer le texte dans la commande
printci-dessus.
Dans n’importe quel autre terminal**, cd dans le répertoire où vit le fichier Python (icecream_tutorial.py), puis entrez python icecream_tutorial.py et frappez Enter.
Avec le " apostrophes dans la commande print, nous passons une variable string à la commande print. Au lieu d’utiliser ", on peut aussi utiliser ', mais il est important d’utiliser le même type d’apostrophe au début et à la fin de la variable chaîne (texte).
Une note marginale: Dans Python3 print est une fonction, pas un mot-clé comme dans Python2. print est utile, par exemple, pour faire un script montrer où il est actuellement en cours d’exécution. Il est également possible d’imprimer d’autres types de variables que les chaînes de caractères, mais la combinaison de variables numériques et de variables textuelles nécessite plus d’encodage (voir les sections suivantes).
Variables Python et types de données¶
The above-shown print function already involved string variables. In addition, there are a couple of other variable (data) types in Python:
texte
booléen
Numéro (numérique)
Tuple
liste
dictionnaire
Texte¶
Les variables textuelles dans Python sont strings (str) qui se composent de multiples caractères (chr):
| Type | Example | Description |
|---|---|---|
| str | "apple" | String embraced with double quotes |
'apple' | String embraced with single quotes | |
"""apple""" | Literal string (multi-line text) | |
| chr | "a" | Character (unit of a string) |
| Type | Example | Description |
|------|:-----------:|------------------------------------|
| str | `"apple"` | String embraced with double quotes |
| | `'apple'` | String embraced with single quotes |
| | `"""apple"""` | Literal string (multi-line text) |
| chr | `"a"` | Character (unit of a string) |
En outre, les variables de chaîne ont certaines fonctions intégrées qui facilitent le codage. Pour créer (instantané) une variable de chaîne, utilisez le signe = comme suit :
flavor1 = "vanilla" # str
first_letter = "v" # str / char
print(flavor1.upper())
print(flavor1[0])
print(flavor1.split("ll")[0])VANILLA
v
vani
Les caractères peuvent être convertis en nombres et l’inverse. La fonction intégrée ord() retourne le point de code Unicode d’un caractère, et chr() fait l’inverse. Ceci est utile, par exemple, pour itérer les listes par ordre alphabétique.
print(ord("c")) # character -> integer (Unicode code point)
print(chr(99)) # integer -> character99
c
Booléen¶
Les variables booléennes sont soit True (1) ou False (0) avec de nombreuses implémentations de code utiles. Nous reviendrons plus tard dans la section sur les déclarations conditionnelles (if ...).
bowl = False
print("The bowl exists: " + str(bowl))The bowl exists: False
Nombres (numériques)¶
Python connaît plusieurs types de données numériques :
| Type | Example | Description |
|---|---|---|
int | 10 | Signed Integer |
float | 5.382 | Floating point real number |
complex | 1.43j | Complex number; j (or J) denotes the imaginary unit |
Pour créer une variable numérique, utilisez le signe = comme suit :
scoops = 2 # int
weight = 0.453 # floatPython n’exige pas d’attribution de type pour une variable car il s’agit d’un langage de programmation interprété de haut niveau** (autre que C++ par exemple). Cependant, une fois qu’une variable a été attribuée un type de données, ne la modifiez pas dans le code (c’est juste une bonne pratique - de sorte que les scoops restent entiers).
Si une instruction d’impression combine des variables numériques et textuelles, les variables numériques doivent d’abord être converties en texte, puis concaté en chaîne. Il existe plusieurs façons de combiner plusieurs variables dans une chaîne de texte :
print("My ice cream consists of %d scoops." % scoops) # use %d for integers, %f for floats and %s for strings
print("My ice cream weighs %1.3f kg." % weight)
print("My ice cream weighs " + str(weight) + " kg.")
print("My ice cream weighs {0} kg and has {1} scoops".format(weight * scoops, scoops)) # multiple variable conversion
# f-strings (Python 3.6+) are the modern, preferred way to format text:
print(f"My ice cream weighs {weight:.3f} kg and has {scoops} scoops.")My ice cream consists of 2 scoops.
My ice cream weighs 0.453 kg.
My ice cream weighs 0.453 kg.
My ice cream weighs 0.906 kg and has 2 scoops
My ice cream weighs 0.453 kg and has 2 scoops.
print("My ice cream weighs " + weight + " kg.") # this cannot work because weight is a float---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[7], line 1
----> 1 print("My ice cream weighs " + weight + " kg.") # this cannot work because weight is a float
TypeError: can only concatenate str (not "float") to strListe¶
Une liste est une série de valeurs, qui est embrassée avec des crochets []. Les valeurs peuvent être n’importe quel autre type de données (c.-à-d., numérique, texte, dictionnaire ou tuple), ou même une autre liste (appelée listes nested).
flavors = ["chocolate", "bread", flavor1] # a list of strings
nested_list = [[1, 2, 3], ["a", "b", "c"]]
print(nested_list)
print("A list of strings: " + str(list("ABC")))[[1, 2, 3], ['a', 'b', 'c']]
A list of strings: ['A', 'B', 'C']
Les éléments d’une liste sont appelés entries et entries peuvent être ajoutés, insérés ou supprimés d’une liste.
Les listes ont également de nombreuses fonctions intégrées utiles:
flavors.append("cherry") # append an entry at the end
print(flavors)
flavors.insert(0, "lemon") # insert an entry at position 0
print(flavors)
print(f"There are {len(flavors)} flavors in my list.")
print(*flavors) # print all elements of the list (note: cannot be concatenated to a str)
print("This is all I have: " + str(flavors[:]).strip("[]"))
del flavors[2] # bread is not a flavor, so let's remove it
print("This is all I have: " + ", ".join(flavors)) ['chocolate', 'bread', 'vanilla', 'cherry']
['lemon', 'chocolate', 'bread', 'vanilla', 'cherry']
There are 5 flavors in my list.
lemon chocolate bread vanilla cherry
This is all I have: 'lemon', 'chocolate', 'bread', 'vanilla', 'cherry'
This is all I have: lemon, chocolate, vanilla, cherry
Tuple¶
Un tuple représente une collection d’objets Python, semblable à une liste, et la séquence de valeurs (types de données) dans un tuple peut prendre n’importe quel type. Les éléments d’un tuple sont également indexés avec des entiers. Contrairement aux listes, un tuple est embrassé par des parenthèses rondes () et un tuple est immuable alors que lists sont mutables. Cela signifie qu’un objet tuple ne peut plus être modifié après sa création. Alors pourquoi voudrais-tu utiliser des tuples ? La réponse est qu’un tuple est plus efficace en mémoire qu’un objet mutable car le tuple immuable peut créer des références aux objets existants. En outre, un tuple peut servir de key d’un dictionnaire (voir ci-dessous), ce qui n’est pas possible avec une liste.
a_tuple = ("a text element", 1, 3.03) # example tuple
print(a_tuple[0])
print(a_tuple[-1]) # last element of a tuple (this also works with lists ..)
# comparison of lists and tuples
import time # we need this package (module here) and we will learn more about modules later
print("patience ...")
# iterate over a list with 100000 elements
start_time = time.perf_counter()
a_list = [] # empty list
x = range(100000)
for item in x: a_list.append(item)
print("Run time with list: " + str(time.perf_counter() - start_time) + " seconds.")
# iterate over a tuple with 100000 elements with modifying the tuple
start_time = time.perf_counter()
new_tuple = () # empty tuple
x = range(100000)
for item in x: new_tuple = new_tuple + (item,)
print("Run time with tuple modification: " + str(time.perf_counter() - start_time) + " seconds.")
# iterate over a tuple with 100000 elements if no modification of the tuple is needed
start_time = time.perf_counter()
new_tuple = tuple(range(100000))
for item in new_tuple: pass
print("Run time without tuple modification: " + str(time.perf_counter() - start_time) + " seconds.")a text element
3.03
patience ...
Run time with list: 0.011113214000033622 seconds.
Run time with tuple modification: 12.448654852999425 seconds.
Run time without tuple modification: 0.006154237000373541 seconds.
Dictionnaire¶
Les dictionnaires sont un type de données puissant en Python et ont la structure de base my_dict = {key: value}. Contrairement aux listes, un élément d’un dictionnaire est appelé en invoquant un key plutôt qu’un numéro d’entrée. Un dictionnaire n’est pas énuméré et keys indique simplement leur values (quel que soit le type de données, le value est).
my_dict = {1: "Value 1", 2: "Value 2"}
another_dict = {"list1": [1, 2, 3], "number2": 1}
my_dict [1]'Value 1'Les dictionnaires ont aussi de nombreuses fonctions intégrées utiles:
my_dict.update({3: "Value 3"}) # add a dictionary element
my_dict
del my_dict[1] # delete a dictionary element
len(my_dict) # get the length (number of dictionary elements)2En outre, deux listes de la même longueur peuvent être “zippées” dans un dictionnaire:
weight = [0.5, 1.0, 1.5, 2.0]
price = [1, 1.5, 1.8, 2.0]
apple_weight_price = dict(zip(weight, price))
print("{0} kg apples cost EUR {1}.".format(weight[2], apple_weight_price[weight[2]]))1.5 kg apples cost EUR 1.8.
Ensembles¶
Un ensemble Python est un objet mutable qui est instantané avec des crochets bouclés. Les ensembles ne sont pas ordonnés (contrairement aux listes et aux tuples), et donc utiles pour les opérations mathématiques, telles que l’union, l’intersection, la différence ou la différence symétrique des ensembles d’éléments. Le bloc de code ci-dessous présente l’invocation de deux ensembles et l’application d’opérateurs mathématiques.
ice_shop_a = {"vanilla", "chocolate", "green"}
ice_shop_b = {"blue", "chocolate", "vanilla"}
print("Ice shops united: " + str(ice_shop_a | ice_shop_b))
print("Both shops offer in common: " + str(ice_shop_a & ice_shop_b))
print("This is what shop a has, but not shop b: " + str(ice_shop_a - ice_shop_b))
print("This is what shop b has, but not shop a: " + str(ice_shop_b.difference(ice_shop_a)))
print("This is what is unique to both shops (symmetric difference): " + str(ice_shop_a ^ ice_shop_b))Ice shops united: {'green', 'vanilla', 'chocolate', 'blue'}
Both shops offer in common: {'vanilla', 'chocolate'}
This is what shop a has, but not shop b: {'green'}
This is what shop b has, but not shop a: {'blue'}
This is what is unique to both shops (symmetric difference): {'green', 'blue'}
Opérateurs¶
Les opérateurs suivants comparent les types de données et les valeurs booléennes de sortie (Trueor False):
a == ba égale b (même valeur)a is ba est b (même objet en mémoire — un test plus strict que==)a and ba et ba or ba ou ba <= ba inférieur ou égal à b (similaire sans signe égal)a >= ba supérieur ou égal à b (similaire sans signe égal)a in ba dans b (par exemple, test d’adhésion dans une chaîne ou une liste — voir l’exemple ci-dessous)
print(not False)
print(1 == 1) # value equality
print(1 == 2)
print("ice" in "ice cream") True
True
False
True
Vérification de la réussite en apprentissage¶
Prenez le test de réussite d’apprentissage pour ce carnet Jupyter.
Unfold QR Code
