uments signifie que l'on va introduire un bloc de code, ce sera le bloc de code de la fonction.
<code python>
def f(a, b, c):
print(a, b, c)
</code>
Ici le bloc contient une seule instruction, appela
sque on définit une fonction, comme par exemple:
<code python>
def sum(a,b):
# bloc d'instructions
# de la fonction sum
# ...
</code>
Les variables *a* et *b* sont désignés **param... de définir les **paramètres d'une fonction**.
<code python>
def agenda(nom, prenom, tel):
""" reto... oe', 'prenom': 'John', 'tel': '06 52 47 66 87'}
</code>
Ce fonctionnement est classique. Seulement, on
Python: Portée des variables ======
Un *bloc de code* est un ensemble d'instructions contiguës indenté... tée d'une variable** détermine de quel endroit du code on peut accéder à cette variable. Python utilise ... e est déterminée en fonction de l'endroit dans le code où cette variable est définie**.
* Une variable locale au bloc de code d'une fonction est ce qu'on appelle une **variabl
a classe que l'on appelle **arbre d'héritage**.
<code python>
class Phrase:
"La classe Phrase défin... de classe partagée par toutes les instances
</code>
Pour créer une classe, on utilise l'instruction... on.'.
Maintenant, regardons cet objet `Phrase`.
<code python>
>>> print(Phrase)
<class '__main__.Phrase'>
</code>
L'interpréteur a bien créé un objet "Phrase". À
es:
Pour l'exemple on définit une classe Point1
<code python>
class Point1:
def __init__(self, x, y... ):
return f"Point1[{self.x}, {self.y}]"
</code>
Avec ce code, les instances de Point sont mutables:
<code python>
>>> p1 = Point1(2, 2)
>>> p2 = Point1(2, 3)
# L'
rtagées.
Lorsqu'on fait une affectation simple:
<code python>
>>> a = 3
</code>
À gauche, j'ai l'espace de mes variables, que l'on appellera **espace de nom... ence vers mon entier.
Si par la suite on tape:
<code bash>
>>> a = 'spam'
</code>
Python crée un objet **'spam'** de type chaîne de caractères, compteur de
ratrices**.
===== Expression génératrice =====
<code python>
# compréhension de liste simple
# produit... mémoire
>>> carre = [x**2 for x in range(1000)]
</code>
Cette liste est créée en mémoire et contient le... n peut utiliser la fonction *built-in* ''sum'':
<code python>
>>> sum(carre)
332833500
</code>
Pour calculer la somme de ces éléments, on peut éviter de cré
une troisième classe C, qui hérite de C1 et C2.
<code python>
# déclaration de la classe C1
class C1:
... C héritant de C1 et C2
class C (C1, C2):
pass
</code>
En Python cette notion d'héritage est représent... on d'héritage on s'appuie sur une classe Phrase.
<code python>
s = 'Je fais un MOOC sur Python'
class P... f, phrase):
self.mots = phrase.split()
</code>
La première ligne déclare une chaîne de caractèr
n englobante.
===== L'instruction global =====
<code python>
# la variable *a* est définie au niveau
#... n vérifie la valeur de a
>>> print(a)
a globale
</code>
La variable *a* est définie au niveau du module... , on ajoute l'instruction *global a*, le reste du code reste inchangé:
<code python>
# la variable *a* est définie au niveau
# du module, sa portée est globa
rables*. Regardons cela avec un exemple simple.
<code python>
# création d'un ensemble s
>>> s = { 1, 2... >>> [x for x in s if type(x) is int]
[1, 2, 3]
</code>
Cette compréhension de liste retourne la liste d... tancier un objet *iterateur* sur l'ensemble *s*.
<code python>
>>> it = iter(s)
# on affiche le type de l'objet it
>>> type(it)
set_iterator
</code>
**iter** est la fonction *built-in* qui permet
plement une facilité d'utilisation pour écrire du code qui dans certains cas peut être plus conçis et pl... .
Regardons comment écrire une fonction lambda:
<code python>
# le mot clé lambda est suivi des paramètres
>>> lambda x: x**2 - 1
</code>
Le mot-clé *lambda* est suivi d'un paramètre, on... ion nommée un peu comme une fonction classique.
<code python>
# la variable carre référence la fonction
outer donc ce tuple vide a assez peu d'intérêt.
<code python>
# instancier un tuple vide
>>> t1 = ()
#... e l'objet est bien un tuple
>>> type(t1)
tuple
</code>
Pour créer **un tuple avec un élément**, attention à la notation:
<code python>
>>> t = (4,)
>>> type(t)
tuple
>>> len(...
1
</code>
Vous remarquez qu'on a rajouté une virgule derr
e vous commencez à écrire votre première ligne de code. Nous allons voir dans la suite comment est-ce qu... constante *x* et une fonction f qui l'affiche:
<code python spam.py>
""" Le module spam contient une v... t une fonction"""
x = 1
def f():
print(x)
</code>
On définit un deuxième fichier python, `egg.py`, comme ceci:
<code python egg.py>
import spam
x = 2
def f():
p
, on utilise l'instruction import, par exemple:
<code python>
# Importation du module os
>>> import os
... )
<module 'os' from '/usr/lib/python3.8/os.py'>
</code>
Le mot après l'instruction ''import'', ici ''os... er à la valeur de cette variable `PYTHONPATH`:
<code python>
>>> print(os.environ['PYTHONPATH'])
</code>
si le fichier n'est pas présent, au final, l’inter
