Pourquoi python?¶

Très lisible, orienté présentation
Pragmatique (non dogmatique)
Enormement de librairies standard
Portable
Très grosse base de code (installable par pip par exemple)
- Scientifique à la mathlab
- Traitement de données
- Web et framework web
- Et bien plus
Peut être interfacé avec d'autre language Java, C, C++ (exemple Py4J permet aux programmes Python exécutés dans un interpréteur Python d'accéder dynamiquement aux objets Java dans une machine virtuelle Java.)
developpement plutot rapide:
- type de base puissant
- Gestion automatique de la mémoire
- Language interprété et notebook jupyter (comme celui ci)
Multi-paradigme
importante documentation
- python.org
- stackoverflow
Des success stories
- Google, Youtube, DropBox, instagram
- spotify, Mercurial, OpenStack, Miro, Reddit, Ubuntu, ...

Les languages les plus populaire en 2020 et salaire moyen

Les bases du language¶

Les commentaires¶

Les commentaires introduits par # qui se terminent avec la ligne :

pour rappeler les étapes non élémentaires identifiées lors du raffinage ;
pour expliciter le rôle d’une variable : après la déclaration ;
pour expliquer une instruction : mis à la fin de la ligne

Les commentaires entre “”” (triple “) pouvant être sur plusieurs lignes :

pour exprimer une propriété qui doit être vérifiée à l’exécution du programme.
pour documenter des modules, fonctions, procedures
Voir aussi structures de contrôle.

Un algorithme est composé de trois catégories principales d’éléments¶

une définition permet de définir les « entités » qui pourront être manipulées dans l’algorithme. En particulier, on définit des constantes, des types et des sous-programmes (fonctions).
une déclaration permet de déclarer les données qui sont utilisées par le programme. Les données sont stockées par des variables. EN PYTHON LES DÉCLARATION NE SONT PAS OBLIGATOIRE, donc à la première utilisation ou en début de bloc on décrira les variable dans des commentaires
Les instructions constituent le programme principal. Elles sont exécutées par l’ordinateur pour transformer les données.

Aspect impératif de Python : Instruction, expression, Flot d’instructions¶

[x] Instruction $\Rightarrow$ modifie l’état
[x] Expression $\Rightarrow$ fournit un résultat

$$ {x:?} \color{red}{\xrightarrow{x = \color{blue}{a + b}}} {x:val(a)+val(b)}$$

Données et structure de données :

[ ] atomique
[ ] Séquence
[ ] structures complexe

Flot d’instructions :

[ ] Séquence $\Rightarrow$ bloc d’instruction
[ ] conditions $\Rightarrow$ if else
[ ] Répétition $\Rightarrow$ while
[ ] appel de procédures (instruction) ou appel de Fonctions (expression)

Definition de bloc / nommer un flots d'instruction / sous-programme :

[ ] procédures (instruction)
[ ] Fonctions (expression)
[ ] Modules (nous y reb=viendrons avec le paradigme Objet)
[ ] Objet (nous y reb=viendrons avec le paradigme Objet)

L’unique instruction : affectation!¶

L’affectation permet de modifier la valeur d’une variable. C’est donc la seule instruction : elle modifie l’état.

Remarque : L'affectation est parfois caché (effet de bord) par des traitements lors de l’appel d’une procédure

Une donnée se trouve en mémoire: elle à une référence (son adresse)

En fonction de son type : elle prend un certain espace (une taille) en mémoire. Le type permet de connaître la taille.

Comment manipuler les données? Soit on connaît leurs références, soit on les étiquette (on les nomme)

Les variable en Python sont des noms¶

En Python les variables (sont nommé “nom d’une donnée”) représente en fait la référence vers les données.

x = 2
y = [1, 2]

Car en fait tout est objet (tout est référence)

ref

en python la fonction id donne la référence

id(x)

10914528

id(2)

10914528

Remarquer que x et 2 ont la même référence! (ie le même identifiant)

Les données ont un type la fonction `type` en pythion¶

type(x)

int

type(y)

list

x = 2.0
y = x
print(x, y, type(x), type(y), id(x), id(y), id(2.0))

2.0 2.0 <class 'float'> <class 'float'> 140209198024752 140209198024752 140209199138000

avez vous bien comprios la notion de type, nom, données atomique, référence (identifiant)?¶

Voici une séquence :

z = 3.0
print("Z : ", z, id(z), type(z))
w = z
print("W : ", w, id(w), type(w))

Z :  3.0 140209122029808 <class 'float'>
W :  3.0 140209122029808 <class 'float'>

Le résultat de l'exécution de la cellule vous semble compréhensible?

En Python, on pourra par exemple faire¶

x = 2
x = 3.0
x = [1, 2, 3]

car x est le nom (la référence) il designera une nouvelle référence après l'affectation

x = 2
print(x, type(x), id(x))
x = 2.0
print(x, type(x), id(x))
x= [1, 2, 3]
print(x, type(x), id(x))

2 <class 'int'> 10914528
2.0 <class 'float'> 140348421915416
[1, 2, 3] <class 'list'> 140348421204872

# c'est quoi d'après vous?
globals()['x']

[1, 2, 3]

Données muttable et immutable¶

L’assignation par référence n’a vraiment d’influance (effet sur l'état) que dans le cas où un objet est mutable.

En Python, il existe en effet deux types d’objets:

les mutables (listes, dictionnaires, sets, objets custo, etc) et
les non mutables (strings, int, floats, tuples, etc).

Les mutables sont ceux qu’on peut modifier après leur création.

Les non mutables sont ceux qu’on ne peut pas modifier après création.

On ne peut pas modifier 152 une fois que l’objet int est créé. Mais on peut rajouter des éléments à une liste après qu’elle soit créée. Les ints sont non mutables. Les listes sont mutables. Cela peut surprendre, mais les strings sont non mutables. Même quand vous faites:

pa = "papa"
pi = pa.replace("p", "m")
print(pa, id(pa))
print(pi, id(pi))

papa 140209122114224
mama 140209166950256

L'impératif¶

Affectation
Bloc d'instructions

# L'affectation, l'affectation //
x = 3.0
y,z = 10,x
print(x,y,z)
# Echange de valeurs entre 2 variables en 1 instruction
x,y = y,x
print(x,y)

A = 10
B = 100
A = B
B = A
print(A,B)

100 100

# Mais 
A,B = 10,100
print("1. ",A,B)
A,B = B,A
print("2. ",A,B)

1.  10 100
2.  100 10

Bloc et instructions¶

Un programme en paradigme impératif Python est composé d'instructions.

En Python les limites des instructions et des blocs sont définies par la mise en page.
- Pas de point-virgule (;) à la fin de chaque instruction comme en Java Mais juste un saus de ligne le caractère de fin de ligne (symbolisé par "\n" newLine).
- Les accolades { ... } pour le début et la fin de bloc sont remplacées par les niveaux d'indentations, terminé par une ligne blanche

En définitive, Python oblige à écrire du code lisible, et à prendre de bonnes habitudes conservables dans d'autres langages, ce qui en est fait un langage idéal pour apprendre la programmation. Je sais ce n'est pas votre cas, mais....

Organiser un porgramme Python¶

Un programme Python est construit à partir de blocs de code. Un block est un morceau de texte de programme Python qui est exécuté en tant qu'unité. Les éléments suivants sont des blocs :

un module,
un corps de fonction ou de procédure (sous-programme)
et une définition de classe. (une meilleure organisation des module?)

Pour vous, comment programmer en Python¶

Sans rien installer dans Goolge collab (comme ce cours)
Windows: installer Python directement depuis Windows store avec un EDI simple par exemple VS code
Linux: En natif ou installer WSL (Windows Subsystem for Linux) et travailler dans un environnement Linux depuis Windows
d'autres outils nécessaires pour vos développements: git, github, ssh

Parcourons les basiques¶

quelques présentations rapide avant de détailler les différentes structuration d'un programme Python.

pour apprendre un nouveaux language il faudrait apprendre comment faire ceci:

affectation
bloc
conditions
repétition
Les types de données prédéfinies
Comment créer de nouvaux type de données
comment structurer son code par les sous-programmes ou modules

# premier exemple! (sans explication: que fait-il?)
for i in [0, 1, 2]:
    print("valeur :", i)
print("Fin")

Noter le : et les tabulations, pas besoin de begin/end ou {, } ni de ; pour faire des blocs d'instructions

Les expressions¶

(3 * 4) + 2

L'affectation¶

profitons en m^me temps de présenter queleus type de base dans python (enter, flotant, chaine de caractères (string)

x = (3 + 5) / 4
y = 2 * x
z = "Un texte"
w = 'un autre texte'
#Du texte formaté f""
A = f"x={x} et y={y}"
C = "x={x} et y={y}"
B = None

Vérifier les valeurs des variables x,y,z,w,A et B

Essayer la différence entre / et //¶

Les opérateurs sont des caractères ou des chaines de caractères qui on un sens en fonction du type de données manipulé:

+, -, *, /, //, %, ...

f"le / {5/2} et // {5//2}"

La fonction print

# La fonction print
print(f"le / {5%2} et // {5//2}")
print(5*x)

La Conditionelle¶

condition = True

if (condition):
  x = 2
  print(x)
else:
  y = 5
  print(y)

if (condition): 
  print ("Vraie") 
else: 
  print("Faux")

Essayer avec condition False si elle était True et True si elle était False

La répétition¶

x = 10
while (x > 0):
  print(x, end=' ')
  x = x -1

La répétition par itérateur `for`¶

for i in range(10):
  print(i, end=':')

help(print)

# cas de range
range(10)

list(range(10))

définition de fonction ou de procedure¶

def f(x,y):
  return (x+y)

f(3,4)

Les listes¶

l = [1,2,3,4,5,6,7]
print(l)

l[4] = 100
l

Les tuples¶

t = (1,2,3,4,5,6)

Les ensembles¶

e = {1, 2, 3, 2, 5}
print(e)

{1, 2, 3, 5}

Les dictionnaire (hash)¶

d = {3:4, "toto":6, "tuple":t}
d

d['titi'] = 11
d

d['ouf']

# Mixons tout ceci
print("Bonjours auditeurs UTC503!")
a,b=0,10
if (a == 0):
  x=b
else:
  x = a + b

#La ligne blanche au dessus exprime la fin du if (tout simplement) ou le retour a la tabulation précedente
while (x < 15):
  print(x)
  x =  x + 1

print(a,b,x)

Bonjours auditeurs UTC503!
10
11
12
13
14
0 10 15

# Ca marche aussi
print("Bonjours auditeurs UTC503!")
a,b=0,10
if (a == 0):
  x=b
else:
  x = a + b
while (x < 15):
  print(x)
  x =  x + 1
print(a,b,x)

Bonjours auditeurs UTC503!
10
11
12
13
14
0 10 15

![if else](https://issae.github.io/images/ifelse.png)

De l'importance des tabulations et des riques de la simplicité¶

J'en profite pour introduire des astuces de la fonction print

Une fonction fantastique : help

help(print)

x,a = 0,0
print("1.",x,a,sep=" : ")
while (x < 10):
  x = x + 1
  print("2.* Dans la boucle x=", x, sep="", end=" ")
  a = a + 1
print("\n3. a la sortie de la boucle x>=10", x)
print("4. Que vaut a?", a)

1. : 0 : 0
2.* Dans la boucle x=1 2.* Dans la boucle x=2 2.* Dans la boucle x=3 2.* Dans la boucle x=4 2.* Dans la boucle x=5 2.* Dans la boucle x=6 2.* Dans la boucle x=7 2.* Dans la boucle x=8 2.* Dans la boucle x=9 2.* Dans la boucle x=10 
3. a la sortie de la boucle x>=10 10
4. Que vaut a? 10

# Le même?
x,a = 0,0
print("1.",x,a,sep=" : ")
while (x < 5):
  x = x + 1
  print("2.* Dans la boucle x=", x, sep="", end=" ")
a = a + 1
print("\n3. a la sortie de la boucle x>=10", x)
print("4. Que vaut a?", a)

1. : 0 : 0
2.* Dans la boucle x=1 2.* Dans la boucle x=2 2.* Dans la boucle x=3 2.* Dans la boucle x=4 2.* Dans la boucle x=5 2.* Dans la boucle x=6 2.* Dans la boucle x=7 2.* Dans la boucle x=8 2.* Dans la boucle x=9 2.* Dans la boucle x=10 
3. a la sortie de la boucle x>=10 10
4. Que vaut a? 1

# Conseil, mettre une ligne blanche pour séparer les blocs. C'est encore plus lisible ;)
x,a = 0,0
print("1.",x,a,sep=" : ")

while (x < 5):
  x = x + 1
  print("2.* Dans la boucle x=", x, sep="", end=" ")
  a = a + 1

print("\n3. a la sortie de la boucle x>=10", x)
print("4. Que vaut a?", a)

1. : 0 : 0
2.* Dans la boucle x=1 2.* Dans la boucle x=2 2.* Dans la boucle x=3 2.* Dans la boucle x=4 2.* Dans la boucle x=5 2.* Dans la boucle x=6 2.* Dans la boucle x=7 2.* Dans la boucle x=8 2.* Dans la boucle x=9 2.* Dans la boucle x=10 
3. a la sortie de la boucle x>=10 10
4. Que vaut a? 10

Les variables et leur type¶

Les langages de programmation impératif, (vous le saurez ;)

manipule des valeurs en mémoire.
et leur évolution grâce à l'exécution d’instructions

=> La variables, représente une association (on dit aussi une liaison) entre un symbole et une valeur. Le symbole (comme une étiquette sur un document) permettant au programmeur d'identifier et manipuler ces valeurs.

Le typage d'une variable consiste à associer un « type » de donnée [une méta donnée une information], permettant au langage de savoir si celle-ci est de type numérique, textuel, etc.,

d'allouer en conséquence des zones de mémoire de dimension suffisantes pour stocker cette donnée,
et éventuellement de vérifier que les manipulations programmées sur cette variable (opérations mathématiques, traitement de texte, etc.) sont cohérentes avec son type.

Typage dynamique¶

Le typage dynamique consiste à laisser le langage réaliser cette opération de typage « à la volée », lors de l'exécution du code.

Un langages statiquement typés demandent au programmeur de déclarer expressément, pour chaque variable qu'il introduit dans son code, son typage.

Le typage dynamique est une solution très commode pour le développement rapide de programmes, où

le type des objets manipulés n'est pas forcément connu à l'avance,
ou bien le programmeur veut permettre par commodité le changement de type d'une variable.

# la variable est définie en python lors de la première opération d'affectation
x = 3
y = k + x

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-23-715c43cd2d46> in <module>()
      1 # la variable est définie en python lors de la première opération d'affectation
      2 x = 3
----> 3 y = k + x

NameError: name 'k' is not defined

interprété vs compilé¶

On peut distinguer deux grands types de langages : les langages interprétés et les langages compilés.

Le langage interprété plutôt typage dynamique

Le langage compilé plutôt typage statique

interprete compile

Pour en savoir plus sur les variables et les opérateurs, lire et relire si nécessaire ¶

https://utc503.page.link/variables