Types de variables Python

Types de Variables en Python

Les variables sont des concepts fondamentaux en programmation, agissant comme des conteneurs nommés pour stocker des valeurs de données en mémoire. Lorsque vous créez une variable en Python, vous réservez de l’espace mémoire pour les données qu’elle contiendra.

Python est un langage à typage dynamique (dynamically typed), ce qui signifie que vous n’avez pas besoin de déclarer explicitement le type d’une variable à l’avance. L’interprète détermine automatiquement le type en fonction de la valeur qui lui est attribuée.

Attribution de Valeurs aux Variables

Utilisez l’opérateur d’affectation (=) pour attribuer une valeur à une variable. Le nom de la variable se trouve à gauche, et la valeur à droite.

# Affectations de variables
counter = 100          # Une affectation d'entier
pi_value = 3.14159     # Une affectation de nombre à virgule flottante
name = "Alice"         # Une affectation de chaîne de caractères
is_active = True       # Une affectation de booléen
my_list = [1, 2, 3]    # Une affectation de liste

# Utilisation des variables
print(counter)
print(pi_value)
print(name)
print(is_active)
print(my_list)

Sortie :

100
3.14159
Alice
True
[1, 2, 3]

Affectations Multiples

Python permet d’attribuer une seule valeur à plusieurs variables simultanément :

x = y = z = 0 # Les trois variables référencent le même objet entier 0
print(x, y, z)

Vous pouvez également attribuer plusieurs valeurs distinctes à plusieurs variables sur une seule ligne (souvent utilisé pour déstructurer des séquences) :

a, b, city = 1, 2.5, "New York"
print(a)      # Sortie : 1
print(b)      # Sortie : 2.5
print(city)   # Sortie : New York

Types de Données Standard

Python dispose de plusieurs types de données intégrés (built-in data types) qui définissent le type de données qu’une variable peut contenir et les opérations qui peuvent être effectuées sur celle-ci. Les principaux types standard incluent :

• Types Numériques : int, float, complex
• Types Séquentiels : str, list, tuple
• Type de Mappage : dict
• Types d’Ensembles : set, frozenset
• Type Booléen : bool
• Types Binaires : bytes, bytearray, memoryview
• Type Nul : NoneType (n’a qu’une seule valeur : None)

Types Numériques (int, float, complex)

Stockent des valeurs numériques. Ils sont immuables.

int_var = 10
float_var = 12.5
complex_var = 3 + 4j

# Deleting variable references
del float_var
# print(float_var) # Provoquerait une NameError

Types Séquentiels (str, list, tuple)

Représentent des collections ordonnées d’éléments.

Exemple de Chaîne de Caractères :

my_str = 'Hello World!'

print(my_str)          # Sortie : Hello World!
print(my_str[0])       # Sortie : H (Premier caractère)
print(my_str[6:11])    # Sortie : World (Découpage de l'index 6 jusqu'à 11)
print(my_str[6:])      # Sortie : World! (Découpage de l'index 6 jusqu'à la fin)
print(my_str * 2)      # Sortie : Hello World!Hello World!
print(my_str + " Python") # Sortie : Hello World! Python

Exemple de Liste :

my_list = ['abcd', 786, 2.23, 'john', 70.2]
tiny_list = [123, 'john']

print(my_list)         # Sortie : ['abcd', 786, 2.23, 'john', 70.2]
print(my_list[0])      # Sortie : abcd
print(my_list[1:3])    # Sortie : [786, 2.23]
print(my_list[2:])     # Sortie : [2.23, 'john', 70.2]
print(tiny_list * 2)   # Sortie : [123, 'john', 123, 'john']
print(my_list + tiny_list) # Sortie : ['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

# Les listes sont mutables
my_list[2] = 'updated'
print(my_list)         # Sortie : ['abcd', 786, 'updated', 'john', 70.2]

Exemple de Tuple :

my_tuple = ('abcd', 786, 2.23, 'john', 70.2)
tiny_tuple = (123, 'john')

print(my_tuple)        # Sortie : ('abcd', 786, 2.23, 'john', 70.2)
print(my_tuple[0])     # Sortie : abcd
print(my_tuple[1:3])   # Sortie : (786, 2.23)
print(my_tuple[2:])    # Sortie : (2.23, 'john', 70.2)
print(tiny_tuple * 2)  # Sortie : (123, 'john', 123, 'john')
print(my_tuple + tiny_tuple) # Sortie : ('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

# Les tuples sont immuables
# my_tuple[2] = 1000  # Cela provoquerait une TypeError

Type de Mappage (dict)

dict (Dictionnaire) : Collection mutable de paires clé-valeur uniques. Définie à l’aide d’accolades {}. Les clés doivent être des types immuables (comme les chaînes de caractères, les nombres, les tuples). Les valeurs peuvent être de n’importe quel type. Les dictionnaires ne sont pas ordonnés dans les anciennes versions de Python, mais maintiennent l’ordre d’insertion à partir de Python 3.7+.

my_dict = {}
dict_one = {'name': 'john', 'code': 6734, 'dept': 'sales'}

my_dict['one'] = "This is value one"
my_dict[2] = "This is value two"

print(my_dict['one'])       # Sortie : This is value one
print(my_dict[2])         # Sortie : This is value two
print(dict_one)           # Sortie : {'name': 'john', 'code': 6734, 'dept': 'sales'}
print(dict_one.keys())    # Sortie : dict_keys(['name', 'code', 'dept'])
print(dict_one.values())  # Sortie : dict_values(['john', 6734, 'sales'])

Types d’Ensembles (set, frozenset)

Représentent des collections non ordonnées d’éléments uniques et immuables. Utilisés pour les tests d’appartenance, la suppression de doublons et les opérations d’ensemble (union, intersection, etc.).

my_set = {1, 2, 3, 2, 1} # Les doublons sont automatiquement supprimés
print(my_set)           # Sortie : {1, 2, 3} (L'ordre peut varier)

empty_set = set()
print(empty_set)        # Sortie : set()

frozen = frozenset(["a", "b", "c"])
print(frozen)           # Sortie : frozenset({'c', 'a', 'b'})
# frozen.add("d") # AttributeError: L'objet 'frozenset' n'a pas d'attribut 'add'

Type Booléen (bool)

Représente les valeurs de vérité. N’a que deux valeurs possibles : True et False (attention à la capitalisation). C’est souvent le résultat de comparaisons ou d’opérations logiques.

is_valid = True
has_error = False
print(is_valid)         # Sortie : True
print(5 > 3)            # Sortie : True
print(type(False))      # Sortie : <class 'bool'>

Type Nul (NoneType)

Représente l’absence de valeur. N’a qu’une seule valeur : None. Souvent utilisé comme valeur par défaut ou comme substitut.

result = None
print(result)           # Sortie : None
print(type(None))       # Sortie : <class 'NoneType'>

Conversion de Types de Données

Vous pouvez souvent convertir entre différents types de données en utilisant des fonctions intégrées nommées d’après le type cible.

Fonction	Description
int(x [,base])	Convertit x en un entier. base spécifie la base si x est une chaîne de caractères (par exemple, int('101', 2)).
float(x)	Convertit x en un nombre à virgule flottante.
str(x)	Convertit l’objet x en sa représentation sous forme de chaîne de caractères.
list(s)	Convertit l’itérable s en une liste.
tuple(s)	Convertit l’itérable s en un tuple.
set(s)	Convertit l’itérable s en un ensemble.
dict(d)	Crée un dictionnaire. d peut être une séquence de paires (clé, valeur) ou des arguments nommés.
bool(x)	Convertit x en un booléen. False pour 0, None, les séquences/mappages vides ; True autrement.
complex(real [,imag])	Crée un nombre complexe.
bytes(source [, encoding])	Crée un objet bytes immuable.
chr(i)	Convertit un entier i en son caractère Unicode correspondant.
ord(c)	Convertit un caractère unique c en son point de code Unicode entier.
hex(x)	Convertit un entier en une chaîne hexadécimale en minuscules préfixée par “0x”.
oct(x)	Convertit un entier en une chaîne octale préfixée par “0o”.

Remarque : La fonction long() de Python 2 a été supprimée ; int gère désormais les tailles arbitraires. eval() évalue une chaîne de caractères comme du code Python ; utilisez-la avec une extrême prudence en raison des risques de sécurité. repr() fournit une représentation de chaîne de caractères non ambiguë, souvent utilisable pour recréer l’objet.