<jupyter_start><jupyter_text>"Chapitre 2 : Les variables Python"> "Python : Chapitre 2 - Lesson 1"- toc: false - badges: true- hide_binder_badge: true- hide_github_badge: true- comments: false- layout: post- author: AXI Academy- permalink: /python-intro-gen/chapter/2/lesson/1/  1. CréationUne variable est une étiquette pour un emplacement en mémoire. Il peut être utilisé pour contenir une valeur. Dans les langages à typage statique, les variables ont des types prédéterminés et une variable ne peut être utilisée que pour contenir des valeurs de ce type. En Python, nous pouvons réutiliser la même variable pour stocker des valeurs de tout type.  Création d'une variableCréation de la variable `count`dont la valeur est `0` :<jupyter_code>count = 0<jupyter_output><empty_output><jupyter_text>La portée (scope) des variablesToutes les variables ne sont pas accessibles depuis toutes les parties de notre programme, et toutes les variables n'existent pas pour la même durée. L'endroit où une variable est accessible et sa durée d'existence dépendent de la façon dont elle est définie. Nous appelons la partie d'un programme où une variable est accessible sa portée (scope), et la durée pendant laquelle la variable existe :<jupyter_code># This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function(c):
    # this is a local variable
    d = 3
    print(c)
    print(d)

# Now we call the function, passing the value 7 as the first and only parameter
my_function(7)

# a and b still exist
print(a)
print(b)

# c and d don't exist anymore -- these statements will give us name errors!
print(c)
print(d)<jupyter_output><empty_output><jupyter_text>L'opérateur `=`Cet opérateur affecte la valeur du côté droit à la variable du côté gauche, créant parfois la variable en premier. Si le côté droit est une expression (telle qu'une expression arithmétique), elle sera évaluée avant que l'affectation ne se produise. Voici quelques exemples:<jupyter_code>total = 3

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1


# these are all illegal:
3 = 4
3 = a
a + b = 3

# both a and b will be set to zero:
a = b = 0

# this is illegal, because we can't set 0 to b:
a = 0 = b<jupyter_output><empty_output><jupyter_text>Les opérateurs composés| Operator | Example | Equivalent to || -------- | ------- | ------------- || += | a += 5 | a = a + 5 || -= | a -= 5 | a = a - 5 || *= | a *= 5 | a = a * 5 || /= | a /= 5 | a = a / 5 || %= | a %= 5 | a = a % 5 |  Exercice 1 : - 1) Décrivez le scope des variables `a`, `b`, `c` et `d` dans cet exemple :<jupyter_code>def my_function(a):
    b = a - 2
    return b

c = 3

if c > 2:
    d = my_function(5)
    print(d)<jupyter_output><empty_output><jupyter_text>- 2) Quelle est la durée de vie de ces variables ? Quand seront-elles créés et détruits ? - 3) Pouvez-vous deviner ce qui se passerait si nous attribuions à `c` une valeur de 1 à la place ?  2. ModificationDans certaines langues, il est possible de définir des variables spéciales auxquelles une valeur ne peut être affectée qu'une seule fois – une fois leurs valeurs définies, elles ne peuvent pas être modifiées. Nous appelons ces types de variables des constantes. Python ne nous permet pas de définir une telle restriction sur les variables, mais il existe une convention largement utilisée pour marquer certaines variables pour indiquer que leurs valeurs ne sont pas censées changer : nous écrivons leurs noms en majuscules, avec des traits de soulignement séparant les mots :<jupyter_code># These variables are "constants" by convention:
NUMBER_OF_DAYS_IN_A_WEEK = 7
NUMBER_OF_MONTHS_IN_A_YEAR = 12

# Nothing is actually stopping us from redefining them...
NUMBER_OF_DAYS_IN_A_WEEK = 8

# ...but it's probably not a good idea.<jupyter_output><empty_output><jupyter_text>Les types : mutable et immuableCertaines valeurs en python peuvent être modifiées, d'autres non. Cela ne signifie jamais que nous ne pouvons pas changer la valeur d'une variable - mais si une variable contient une valeur d'un type immuable, nous ne pouvons lui attribuer qu'une nouvelle valeur. Nous ne pouvons en aucun cas modifier la valeur existante.Les entiers, les nombres à virgule flottante et les chaînes sont tous des types immuables - dans tous les exemples précédents, lorsque nous avons modifié les valeurs des variables existantes, nous avons utilisé l'opérateur d'affectation pour leur attribuer de nouvelles valeurs :<jupyter_code>a = 3
a = 2

b = "jane"
b = "bob"

# This operator doesn’t modify the value of total, it assign a new value
total += 4<jupyter_output><empty_output><jupyter_text>Les objets de type mutable peuvent être modifier de différentes manières suivant leur type.<jupyter_code># this is a list of numbers
my_list = [1, 2, 3]
my_list[0] = 5 # we can change just the first element of the list
print(my_list)

# A class is a mutable object type 
class MyClass(object):
    pass

# Now we make a very simple object using our class as a type
my_object = MyClass()

# We can change the values of attributes on the object
my_object.some_property = 42<jupyter_output><empty_output><jupyter_text>3. Les conversionsAu fur et à mesure que nous écrivons des programmes, nous constaterons souvent que nous devons convertir des données d'un type à un autre, par exemple d'une chaîne à un entier ou d'un entier à un nombre à virgule flottante. Il existe deux types de conversions de type en Python : les conversions implicites et explicites. Les conservions implicitesRappelez-vous de la section sur les opérateurs à virgule flottante que nous pouvons combiner arbitrairement des entiers et des nombres à virgule flottante dans une expression arithmétique - et que le résultat d'une telle expression sera toujours un nombre à virgule flottante. En effet, Python convertira les entiers en nombres à virgule flottante avant d'évaluer l'expression. Il s'agit d'une conversion implicite - nous n'avons rien à convertir nous-mêmes. Il n'y a généralement pas de perte de précision lorsqu'un entier est converti en un nombre à virgule flottante.<jupyter_code>a = 8.5 * 2
print(a)

b = 3 / 2
print(b)

c = 8.5 + 7 // 3 - 2.5
print(c)<jupyter_output><empty_output><jupyter_text>Les conservions explicites (cast)La conversion de nombres de `float` en `int` entraînera une perte de précision. Par exemple, essayez de convertir `5.834` en `int` : il n'est pas possible de le faire sans perdre en précision. Pour que cela se produise, nous devons explicitement dire à Python que nous sommes conscients que la précision sera perdue.   Par exemple, nous devons dire au compilateur de convertir un float en un int comme ceci :<jupyter_code>i = int(5.834)
print(i)<jupyter_output><empty_output><jupyter_text>La fonction `int` convertit un `float` en un int en supprimant la partie décimale : elle sera toujours arrondie à l'inférieur. Si nous voulons plus de contrôle sur la façon dont le nombre est arrondi, nous devrons utiliser une fonction différente :<jupyter_code># the floor and ceil functions are in the math module
import math

# ceil returns the closest integer greater than or equal to the number
# (so it always rounds up)
i = math.ceil(5.834)
print(i)

# floor returns the closest integer less than or equal to the number
# (so it always rounds down)
i = math.floor(5.834)
print(i)

# round returns the closest integer to the number
# (so it rounds up or down)
# Note that this is a built-in function -- we don't need to import math to use it.
i = round(5.834)
print(i)
i = round(5.334)
print(i)<jupyter_output><empty_output><jupyter_text>4. Le typageLes langages de programmation possède différentes manières de typer des variables. On va notamment distinguer 2 caractéristiques : Typage statique ou dynamique - **langage à typage statique :** Un langage dans lequel les types sont fixés à la compilation. La plupart des langages à typage statique obtiennent cela en exigeant la déclaration de toutes les variables et de leur type avant leur utilisation. Java et C sont des langages à typage statique. - **langage à typage dynamique :** Un langage dans lequel les types sont découverts à l'exécution, l'inverse du typage statique. VBScript et Python sont des langages à typage dynamique, ils déterminent le type d'une variable la première fois que vous lui assignez une valeur.  Les langages fortement typé ou faiblement typé- **langage fortement typé :** Un langage dans lequel les types sont toujours appliqués. Java et Python sont fortement typés. Un entier ne peut être traité comme une chaîne sans conversion explicite - **langage faiblement typé :** Un langage dans lequel les types peuvent être ignorés, l'inverse de fortement typé. VBScript est faiblement typé. En VBScript, vous pouvez concaténer la chaîne '12' et l'entier 3 pour obtenir la chaîne '123' et traiter le résultat comme l'entier 123, le tout sans faire de conversion explicite.    Python est donc à la fois à typage dynamique (il n'utilise pas de déclaration de type explicite) et fortement typé (une fois qu'une variable a un type, cela a une importance.   On peut connaitre le type d'une variable python avec la fonction `built-in` : `type` :<jupyter_code>print(type('Hello World !'))
print(type(123))
print(type(0.23))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0675547098001903, 'fraction_numerical': 0.012157733375621102, 'mean_word_length': 4.384177575412635, 'pattern_counts': {'":': 0, '<': 45, '<?xml version=': 0, '>': 47, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '439260', 'license': 'Apache-2.0', 'n_tokens_mistral': 3063, 'n_tokens_neox': 2989, 'n_words': 1356, 'path': '_notebooks/2022-01-02-python-intro-gen-2-1-variables.ipynb', 'repo_name': 'AXI-Technologies/AXI-Fastpages', 'size': '9459'}