On peut faire des calculs sur les entiers avec les opérateurs classiques
1+3
5-4
4*5
La puissance est ** et pas ^ qui dénote le ou exclusif.
2**3
2^3
1001^1100
Le quotient de la division euclidienne est // et le reste %. La division normale elle renvoit un nombre à virgule flottante
123//11
123%11
123/11
On peut tester les types via la fonction type
type(11)
On a ici aussi les opérations artithmétiques usuelles.
1.5+1.3
15.0-5
14.*3.
14./3.
14.//3.
2.5**3.4
Outre les chaines de caractères on introduit aussi les premières variables via l'opérateur d'affectation =
message = "Première chaine de caractères"
type(message)
On peut aussi utiliser des triples guillemets pour une chaine de plusieurs lignes
nouvelle = """
Nouvelles chaine de caractères.
On garde les sauts de lignes.
Et éventuellement les alinéas.
"""
La fonction print permet d'afficher les chaines de caractères (et autres variables)
print(message)
print(nouvelle)
On a accès à différentes fonctionnalités via la syntaxe suivante
message.capitalize()
message.upper()
Dans le notebook on pourra explorer les différentes possibilités en appuyant sur TAB après message.. On pourra aussi utiliser cette fonctionnalité pour compléter les noms de variables et de fonctions. On n'hésitera donc pas à utiliser des noms relativement longs et descriptifs.
On pourra aussi voir les arguments et des renseignements simples sur les fonctions en tapant sur MAJ+TAB, à l'intérieur des parenthèses d'un appel de fonctions.
Finalement si après un nom de fonction ou de variable on rajoute ?, on obtiendra une aide plus détaillé.
message.encode()
On explore ici le premier conteneur. Il s'agit d'un conteneur dynamique permettant de stocker des objets hétérogène.
ll = [1,2,3,4]
type(ll)
print(ll)
On peut accéder aux différents éléments via l'opérateur []
ll[0]
ll[3]
ll[3] = 5
print(ll)
On voit que les indices commencent à 0 On peut utiliser des indices négatifs pour parcourir la liste dans l'autre sens
print(ll)
print(ll[-1])
On a là encore beaucoup de fonctionnalités
ll.append(5)
print(ll)
x = ll.pop()
print(ll)
print(x)
ll.reverse()
print(ll)
On pourra aussi utiliser des fonctions qui permettent de ne pas modifier la liste mais d'en renvoyer une nouvelle.
print(ll)
print(sorted(ll))
print(ll)
Si on veut échanger le contenu de plusieurs variables on a une syntaxe permettant de le faire sans variables intermédiaires.
a, b = 1, 2
print(a,b)
a, b = b , a
print(a,b)
a,b,c = 1, 2, 3
print(a,b,c)
a, b, c = b, c, a
print(a,b,c)
On a des possibilités plus avancées avec des listes à gauches
liste = [[1, 2], [3, 4]]
print("la liste vaut : ", liste)
a, b = liste
print("a contient : ", a)
print("b contient : ", b)
On pourra regarder toutes les possibilités sur le site python.org à unpacking par exemple
liste = list(range(6))
print(liste)
a, *b, c = liste
print("a contient : ", a)
print("b contient : ", b)
print("c contient : ", c)
Il ne faut en aucun cas penser en terme de variable contenant des objets, mais plutôt comme des variables ayant des noms mais pas de type pointant vers des objets ayant des types mais pas de noms.
a = [1, 2, 3, 4, 5]
b = [1, 2, 3, 4, 5]
print("les deux variables ont la même valeur :", a == b)
print(a)
print(b)
print("Mais les objets sont distincts")
a.append(6)
print(a)
print(b)
a = [1, 2, 3, 4, 5]
b = a
print("les deux variables on la même valeur :", a==b)
print(a)
print(b)
print("cette fois ci il n'y a qu'un seul objet sous jacent")
a.append(6)
print(a)
print(b)
print("On peut tester cette identité de l'objet sous jacent de la façon suivante")
print(a is b)
Pour les différentes structurations les blocs commencent pas : et sont délimités via l'indentation.
for¶Elle permet de parcourir tous les conteneurs et autres objets itérables...
liste = [1, 2, 3, 4, 5, 6, 7]
for x in liste:
print(x)
for i in range(5, 20):
print(i, " : ", i**2)
On a une syntaxe permettant facilement créer une liste/conteneur à partir d'un autre conteneur, la compréhension de liste.
carres = [x**2 for x in range(1, 11)]
print(carres)
cubes = [x**3 for x in range(1, 11)]
print(cubes)
On peut également itérer sur plusieurs listes en parallèles.
differences = [y-x for x,y in zip(carres, cubes)]
print(differences)
On peut utiliser entre autres les opérateurs de comparaisons :
==, !=, <, >, <=, >=, `is
a, b = 1, 0
if a == b:
print("a est égal à b")
elif a < b:
print("a est strictement plus petit que b")
else:
print("a est strictement plus grand que b")
a = [1, 2, 3]
b = a
if a is b:
print("a et b pointent vers le même objet")
elif a == b:
print("a et b ont même valeur mais pointent vers des objets différents")
else:
print("a et b ont des valeurs différentes")
On peut aussi composer des tests avec and et or
a, b = -1, 1
if (a != b) and (a**2 == b**2):
print("a et b sont opposés")
Finalement on peut tester sur le type de donnée par exemple avant d'effectuer une certaine action dessus.
a = 1
if isinstance(a, int):
print("a est entier")
elif isinstance(a, float):
print("a est un nombre à virgule flottante")
elif isinstance(a, bool):
print("a est un booléen")
On peut regrouper des séquences d'actions dans une fonction via la syntaxe suivante.
def double(x):
return x*2
double(5)
double(5.0)
double([1,2])
On notera que les arguments ne sont pas typés par défaut et que l'action réalisé peut dépendre de l'argument fourni.
On peut également fournir des valeurs par défaut via la syntaxe suivante.
def puissance(x,p=2):
return x**p
puissance(2, 3)
puissance(3)
On peut fournir une explication rapide sur la fonction via une chaine de caractère sur la deuxième ligne qui sera fourni entre autre via l'appel MAJ+TAB
def puissance_bizarre(x):
"""Renvoit x**2 si x est pair et x**3 si x est impair"""
if x % 2 == 0:
return x**2
else:
return x**3
puissance_bizarre(2)
puissance_bizarre(3)
def euclide(a, b):
"""Calcul de pgcd(a,b) via l'algorithme d'Euclide"""
if a < b:
b,a = a,b
while b != 0:
a, b = b, a%b
return a
euclide(3,2)
euclide(2*3*5*7, 3*5*7*11)
On peut voir sur les exemples suivants que le comportement de la fonction est perfectible, on pourra essayer de l'améliorer.
euclide(-5, -2)
euclide(1.5, 0.3)
def racine(a):
"""On va calculer approximativement la racine carrée de a via l'algorithme de Héron"""
x = a
for i in range(10):
x = (x+a/x)/2
return x
racine(2)
racine(3)
Là encore le comportement de la fonction est perfectible, en particulier le nombre d'itérations devrait être adapté selon a.
racine(10**8)
def fibo(n):
"""Calcul des n premiers termes de la suite de Fibonacci"""
resultat = [0, 1]
while len(resultat) < n:
resultat.append(resultat[-1]+resultat[-2])
return resultat
fibo(10)
fibo(20)
def est_premier(n):
"""Renvoit True si n est premier, False sinon"""
if n<0:
n = -n
if n<2:
return False
for i in range(2, n//2+1):
if n%i == 0:
return False
return True
for x in range(1, 30):
print(x, " est-il premier? ", est_premier(x))
def pourcentage_premiers(n):
"""Renvoit le pourcentage de nombres premiers entre 1 et n"""
nombre = 0
for x in range(1, n+1):
if est_premier(x):
nombre += 1
return nombre*100/n
pourcentage_premiers(20)
pourcentage_premiers(100)
pourcentage_premiers(1000)
def Collatz(x, n):
"""Calcul des n premiers termes de la suite de Collatz initialisée par x"""
def regle_Collatz(a):
if a%2 ==0:
return a//2
else:
return 3*a+1
resultat = [x]
while len(resultat) < n:
resultat.append(regle_Collatz(resultat[-1]))
return resultat
Collatz(11, 20)
Collatz(5, 20)
Collatz(12, 20)
De nombreuses fonctionnalités sont disponibles avec python, mais contenues dans des paquets supplémentaires qu'il faut importer.
import math
math.sqrt(2)
math.pi
math.tan(math.pi/3)
Là encore une fois un module importé on pourra l'explorer via TAB après (dans notre cas) math.
import random as rd
aleatoires = [rd.random() for x in range(10)]
print(aleatoires)
entiers_aleatoires = [rd.randint(-10, 10) for x in range(20)]
print(entiers_aleatoires)
On pourra consulter par exemple python.org pour avoir un aperu de la quantité de paquets inclus automatiquement avec python.
De nombreux paquets supplémentaires sont disponibles via pip ou conda dans pyzo ou autres distributions.
On pourra par exemple coder des fonctions :