Variables, Opérateurs et Systèmes de Numération en Python

I. Variables

1.1 Pourquoi des variables ?

En Python, l'affectation d'une variable fonctionne ainsi :
- Une adresse mémoire est une chaîne hexadécimale (ex : 0x7ffd8a905a20) ; la variable (ex : a) est un surnom donné à cette adresse. Le programmeur n'a pas à retenir l'adresse, seulement le nom a.
- Quand on écrit a = 1 : Python crée ou trouve l'objet 1 en mémoire, et lie le nom a à son adresse. a « pointe » vers cette adresse.
- Lorsqu'on affiche a, Python suit le lien pour obtenir la valeur 1. a n'est qu'un alias.
- Ensuite, a = 2 : Python délie a de l'adresse de 1 et le lie à la nouvelle adresse de 2. L'objet 1 reste inchangé.
La variable est l'unité de base des programmes : type + nom + valeur. ```

Déclaration

a = 1 # int b = 2 # int b = 8 # réaffectation

print("a =", a, "type :", type(a)) print("b =", b, "type :", type(b))
Mémoire : Les valeurs sont stockées en mémoire (ex : a = 10, b = 30).

1.2 Introduction aux variables

Étapes : définir (a = 60) puis utiliser (print(a)).
Attention : une variable doit être définie avant utilisation, sinon NameError.

1.3 Exemple rapide

nom = "Marie"
age = 25
note = 88.7
sexe = "F"

print("Informations :")
print(nom, age, sexe, note)

# La virgule ajoute un espace entre les valeurs.
print("Informations :", nom, age, sexe, note)

1.4 Formatage de sortie

1.4.1 Style % (traditionnel, issu du C)

Les symboles de format :

Symbole	Description
%s	Chaîne
%r	Représentation brute (avec quotes)
%d	Entier décimal
%i	Identique à %d
%f	Flottant
%e	Notation scientifique (e minuscule)
%E	Notation scientifique (E majuscule)
%g	Choix automatique entre %f et %e
%x	Hexadécimal minuscule
%X	Hexadécimal majuscule
%o	Octal
%%	Échappement du pourcentage

nom = "Alice"
age = 30
note = 92.3

# Valeur unique
print("Nom : %s" % nom)   # Nom : Alice

# Plusieurs valeurs -> tuple
print("Nom : %s, Âge : %d, Note : %f" % (nom, age, note))

# %r avec guillemets
print("Repr brute : %r" % nom)   # 'Alice'

# Échapper %
print("Progression : %.1f%%" % 87.5)   # 87.5%

Contrôle de la largeur / précision : %[remplissage][alignement][largeur][.précision]type

nb = 42
pi = 3.14159
txt = "Python"

# Largeur 5, alignement droite (défaut)
print("%5d" % nb)        # "   42"

# Alignement gauche
print("%-5d" % nb)       # "42   "

# Remplissage avec zéros (chiffres uniquement)
print("%05d" % nb)       # "00042"

# Flottant : largeur 8, 2 décimales
print("%8.2f" % pi)      # "    3.14"

# Chaîne : tronquer à 3 caractères
print("%.3s" % txt)      # "Pyt"

Bases et notation scientifique :

n = 255
print("Décimal : %d" % n)                     # 255
print("Hexa min : %x" % n)                    # ff
print("Hexa maj : %X" % n)                    # FF
print("Octal : %o" % n)                       # 377

f = 12345.6789
print("Sci e : %e" % f)                       # 1.234568e+04
print("Sci E : %E" % f)                       # 1.234568E+04

Formatage avec dictionnaire :

donnees = {'nom': 'Claire', 'age': 22, 'note': 91.0}
print("Nom : %(nom)s, Âge : %(age)d, Note : %(note).1f" % donnees)

Limitations : types stricts, tuple obligatoire, pas d'expression directe.

1.4.2 Méthode `str.format()` (Python ≥ 2.6)

Utilise des accolades {} comme placeholders.

# Positionnel
print("{} a {} ans.".format("Bob", 23))   # Bob a 23 ans.

# Index
print("{1} a {0} ans. {1} aime Python.".format(23, "Bob"))

# Nommé
print("{nom} a {age} ans.".format(nom="Alice", age=25))

# Mixte (positionnel d'abord)
print("{0} a {age} ans.".format("Charlie", age=28))

1.5 Opérateur `+`

Addition entre nombres.
Concaténation entre chaînes.
Interdit : nombre + chaîne (TypeError).

note = 85.3
print(note + 10)        # 95.3
print("Hello" + " there") # Hello there
print("100" + "98")     # 10098
# print(100 + "98")     Erreur

1.6 Types de données

Type	Description
int	Entiers (ex : 1, -5, 2000)
float	Nombres à virgule (ex : 1.1, -4.5)
bool	True / False
str	Chaînes (guillemets simples ou doubles)

Une variable est créée dès qu'on lui affecte une valeur. Le type est celui de l'objet pointé.
type(objet) donne le type.

1.7 Type entier (int)

Les entiers Python peuvent être très grands (théoriquement jusqu'à 4300 chiffres).

Représentations :

Décimal : 123
Hexadécimal : 0x1F
Octal : 0o77
Binaire : 0b1101

Taille mémoire :

import sys

n1 = 0
n2 = 1
n3 = 2
n4 = 2**15
n5 = 2**30
n6 = 2**128

print(n1, sys.getsizeof(n1), type(n1))
print(n2, sys.getsizeof(n2), type(n2))
print(n3, sys.getsizeof(n3), type(n3))
print(n4, sys.getsizeof(n4), type(n4))
print(n5, sys.getsizeof(n5), type(n5))
print(n6, sys.getsizeof(n6), type(n6))

La taille augmente par paliers de 4 octets.

1.8 Type flottant (float)

Formes :

Décimal : 5.12 ou .512 (0.512)
Scientifique : 5.12e2 (512.0), 5.12E-2 (0.0512)

Limites :

print(sys.float_info.max)   # 1.7976931348623157e+308
print(sys.float_info.min)   # 2.2250738585072014e-308

Précision : utiliser Decimal pour des calculs exacts.

from decimal import Decimal
res = Decimal("8.1") / Decimal("3")
print(res)   # 2.7

1.9 Type booléen (bool)

Valeurs : True et False. Utilisé pour la logique et le contrôle de flux.

a = 100
b = 200
resultat = a > b
print(resultat)          # False
print(type(resultat))    # <class 'bool'>

Détails : True = 1, False = 0 en contexte numérique. Les valeurs non nulles sont considérées comme vraies.

1.10 Chaînes (str)

Créées avec '...' ou "...". Permet l'imbrication de guillemets opposés.

s1 = 'Il a dit : "Bonjour"'
s2 = "Elle a dit : 'Salut'"

Triple guillemets : '''...''' ou """...""" pour conserver la mise en forme.
Chaîne brute : r"..." annule l'interprétation des séquences d'échappement.

s3 = r"ligne1\nligne2"    # affiche le \n littéral

Mécanisme d'internage : Python réutilise les chaînes identiques pour économiser la mémoire. Cela s'applique aux chaînes composées de [a-zA-Z0-9_], de longueur ≤ 1, ou constantes à la compilation.

c1 = "hello"
c2 = "hello"
print(id(c1) == id(c2))   # True (dans certains contextes)

1.11 Conversion de type

Python est à typage dynamique : la varible change de type selon l'affectation.

val = 10
print(type(val))   # int
val = 1.1
print(type(val))   # float
val = "salut"
print(type(val))   # str

Conversion implicite : lors d'opérations, le type le moins précis est converti vers le plus précis (int → float).

x = 10
y = 2.5
z = x + y
print(z, type(z))   # 12.5 float

Conversion explicite : utiliser les fonctions int(), float(), str(), bool(), list(), tuple(), set(), dict(), chr(), etc.

print(int("123"))        # 123
print(float("3.14"))     # 3.14
print(str(456))          # "456"
print(bool(0))           # False

Attention : une chaîne non convertible lève ValueError. La conversion ne modifie pas la variable d'origine.

II. Opérateurs

2.1 Introduction

Symboles spéciaux pour les opérations : arithmétiques, d'affectation, de comparaison, logiques, binaires.

2.2 Opérateurs arithmétiques

Opérateur	Nom	Exemple	Résultat
+	Addition	5+5	10
-	Soustraction	6-4	2
*	Multiplication	3*4	12
/	Division (flottante)	5/5	1.0
%	Modulo (reste)	7%5	2
//	Division entière (troncature vers le bas)	9//2, -9//2	4, -5
**	Puissance	2**4	16

print(10/3)   # 3.3333333333333335
print(9//2)   # 4
print(-9//2)  # -5

# Modulo : a % b = a - (a//b)*b
print(-10 % 3)  # 2
print(10 % -3)  # -2

2.3 Opérateurs de comparaison

Opérateur	Exemple	Résultat
==	4 == 3	False
!=	4 != 3	True
<	4 < 3	False
>	4 > 3	True
<=	4 <= 3	False
>=	4 >= 3	True
is	Identité d'objet	True/False
is not	Non identité	True/False

is compare les références, == les valeurs.

2.4 Opérateurs logiques

and, or, not.

a = 10
b = 20
print(a and b)   # 20 (retourne le dernier évalué)
print(a or b)    # 10
print(not a > b) # True

Court-circuit : and s'arrête dès que False, or dès que True.

2.5 Opérateurs d'affectation

Opérateur	Description	Équivalent
=	Affectation simple	c = a + b
+=	Addition	c += a → c = c + a
-=	Soustraction	c -= a → c = c - a
*=	Multiplication	c = a → c = c a
/=	Division	c /= a → c = c / a
%=	Modulo	c %= a → c = c % a
**=	Puissance	c = a → c = c a
//=	Division entière	c //= a → c = c // a

Échange de variables : a, b = b, a.

2.6 Opérateur ternaire

Syntaxe : valeur_si_vrai if condition else valeur_si_faux.

max_val = a if a > b else b

# Maximum de trois nombres
a, b, c = 30, 50, -1
max1 = a if a > b else b
max2 = max1 if max1 > c else c

2.7 Priorité des opérateurs

Priorité	Opérateurs
Élevée	`(...)`
	`**`
	`*`, `@`, `/`, `//`, `%`
	`+`, `-`
	`>>`, `<<`
	`&`
	`^`
	`\|`
	`in`, `not in`, `is`, `is not`, `<`, `<=`, `>`, `>=`, `!=`, `==`
	`not x`
	`and`
	`or`
Basse	Affectations (`=`, `+=`, …)

2.8 Règles et conventions de nommage (identifiants)

Règles : lettres (a-z, A-Z), chiffres, _ ; ne pas commencer par un chiffre ; ne pas utiliser les mots réservés ; sensible à la casse ; pas d'espaces.

Conventions :

Variables en snake_case, constantes en MAJUSCULES.
Fonctions en snake_case, privées avec __.
Classes en CamelCase (PascalCase).

2.9 Mots-clés

Mots réservés par Python (ex : if, else, while, def, class, …).

2.10 Saisie clavier

input(prompt) : affiche le prompt, attend une saisie, retourne une chaîne.

nom = input("Entrez votre nom : ")
age = int(input("Âge : "))
note = float(input("Note : "))
print(f"Bonjour {nom}, tu as {age} ans et ta note est {note}.")

III. Systèmes de numération

3.1 Représentations des entiers

Binaire : 0b ou 0B (ex : 0b1011)
Octal : 0o ou 0O (ex : 0o77)
Décimal : normal
Hexadécimal : 0x ou 0X (ex : 0xFF)

print(0b111)    # 7
print(0o111)    # 73
print(0x111)    # 273

3.2 Conversions

Autre base → décimal : multiplier chaque chiffre par (base)^(position-1) et sommer.
Décimal → autre base : divisions successives par la base, restes inversés.
Binaire → octal : grouper par 3 bits à partir de la droite.
Binaire → hexadécimal : grouper par 4 bits.
Octal → binaire : chaque chiffre octal → 3 bits.
Hexadécimal → binaire : chaque chiffre hex → 4 bits.

3.3 Nombres binaires et calculs

L'ordinateur utilise le binaire (0/1). Le bit de poids fort est le signe (0 = positif, 1 = négatif).

3.4 Codes : complément à 2 (two's complement)

Positif : code identique pour signe, magnitude, complément.
Négatif :
- Complément à 1 = inversion des bits (sauf signe).
- Complément à 2 = complément à 1 + 1.
Tous les calculs sont faits en complément à 2.

# Exemple 1-3 (en utilisant 8 bits)
# 1 + (-3)
# 1 (complément à 2) : 0000 0001
# -3 (original)        : 1000 0011
# -3 (complément à 1)  : 1111 1100
# -3 (complément à 2)  : 1111 1101
# Addition : 0000 0001 + 1111 1101 = 1111 1110 (complément à 2)
# Convertir en décimal : 1111 1110 - 1 = 1111 1101 (complément à 1), inverser : 1000 0010 = -2

3.5 Opérateurs bitwise

~ : NON bitwise (inverse tous les bits)
& : ET bitwise
| : OU bitwise
^ : XOR bitwise
<< : décalage à gauche (multiplication par 2^n)
>> : décalage à droite (division entière par 2^n, conserve le signe)

a = 2   # 0010
b = 3   # 0011
print(a & b)   # 2 (0010)
print(a | b)   # 3 (0011)
print(a ^ b)   # 1 (0001)
print(~a)      # -3 (inversion)
print(a << 1)  # 4 (0100)
print(a >> 1)  # 1 (0001)

Étiquettes: Python variables type conversion opérateurs formatage de chaîne

Publié le 16 juillet à 14h35

L'Atelier Monstre

Variables, Opérateurs et Systèmes de Numération en Python

I. Variables

1.1 Pourquoi des variables ?

Déclaration

1.2 Introduction aux variables

1.3 Exemple rapide

1.4 Formatage de sortie

1.4.1 Style % (traditionnel, issu du C)

1.4.2 Méthode `str.format()` (Python ≥ 2.6)

1.5 Opérateur `+`

1.6 Types de données

1.7 Type entier (int)

1.8 Type flottant (float)

1.9 Type booléen (bool)

1.10 Chaînes (str)

1.11 Conversion de type

II. Opérateurs

2.1 Introduction

2.2 Opérateurs arithmétiques

2.3 Opérateurs de comparaison

2.4 Opérateurs logiques

2.5 Opérateurs d'affectation

2.6 Opérateur ternaire

2.7 Priorité des opérateurs

2.8 Règles et conventions de nommage (identifiants)

2.9 Mots-clés

2.10 Saisie clavier

III. Systèmes de numération

3.1 Représentations des entiers

3.2 Conversions

3.3 Nombres binaires et calculs

3.4 Codes : complément à 2 (two's complement)

3.5 Opérateurs bitwise

Étiquettes Populaires

L'Atelier Monstre

Variables, Opérateurs et Systèmes de Numération en Python

I. Variables

1.1 Pourquoi des variables ?

Déclaration

1.2 Introduction aux variables

1.3 Exemple rapide

1.4 Formatage de sortie

1.4.1 Style % (traditionnel, issu du C)

1.4.2 Méthode str.format() (Python ≥ 2.6)

1.5 Opérateur +

1.6 Types de données

1.7 Type entier (int)

1.8 Type flottant (float)

1.9 Type booléen (bool)

1.10 Chaînes (str)

1.11 Conversion de type

II. Opérateurs

2.1 Introduction

2.2 Opérateurs arithmétiques

2.3 Opérateurs de comparaison

2.4 Opérateurs logiques

2.5 Opérateurs d'affectation

2.6 Opérateur ternaire

2.7 Priorité des opérateurs

2.8 Règles et conventions de nommage (identifiants)

2.9 Mots-clés

2.10 Saisie clavier

III. Systèmes de numération

3.1 Représentations des entiers

3.2 Conversions

3.3 Nombres binaires et calculs

3.4 Codes : complément à 2 (two's complement)

3.5 Opérateurs bitwise

Étiquettes Populaires

1.4.2 Méthode `str.format()` (Python ≥ 2.6)

1.5 Opérateur `+`