Mis à part les types, les instructions de sélection et d'itération, Python comprend aussi plusieurs expressions et instructions permettant d'effectuer les opérations les plus courantes en un appel de méthode.
 

Il en existe beaucoup, et parfois elles sont très spécifiques. Nous allons en voir quelques unes afin de voir les possibilités de Python, et de mieux comprendre ce que nous avons déjà utilisé.
 

L'expression print.
 

Print est l'expression la plus courante, elle permet d'afficher à l'écran les informations qui la suivent.
 

print "Hello World" # Affichage d'une chaîne

print "Hello %s" % "world" # Affichage avec un argument

print len(liste) # Affichage du résultat d'une méthode
 

L'expression print suis la règle de formatage des chaînes. (voir chapitre 2)
 

L'expression input.
 

Input est une expression qui permet de poser une question à l'utilisateur, et d'en affecter la réponse à une variable.

Input ne supporte que les entiers et attend une entrée avant de continuer.
 

>>> var = input("un entier ? : ")

un entier ? : 4

>>> print var

4
 

L'expression raw_input.
 

Raw_input fonctionne comme input mais permet d'affecter n'importe quel type d'objet à la variable.
 

>>> var = raw_input("Yes/No ? : ")

Yes/No ? : Yes

>>> print var

Yes
 

La fonction dir(x).
 

La fonction dir permet d'énumérer les objets d'un module, les modules déjà chargés, les méthodes d'une classe, etc.
 

>>> dir()

['__builtins__', '__doc__', '__name__', 'var']

>>> import sys

>>> dir()

['__builtins__', '__doc__', '__name__', 'sys', 'var']

>>> dir(sys)

['__doc__', '__name__', '__stderr__', '__stdin__', '__stdout__', 'argv', 'builtin_module_names', 'copyright', 'exc_info', 'exc_type', 'exec_prefix', 'executable', 'exit', 'getrefcount', 'hexversion', 'maxint', 'modules', 'path', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'settrace', 'stderr', 'stdin', 'stdout', 'version']
 
 

La fonction type(objet).
 

Type retourne le type de l'objet envoyé en argument.
 

>>> type(10)

<type 'int'>

>>> type("hello")

<type 'string'>
 

La fonction abs(nombre).
 

Abs retourne la valeur absolue du nombre envoyé en argument.
 

>>> abs(-8)

8
 
 

La fonction cmp(x, y).
 

Cmp compare deux arguments et retourne une valeur négative si le premier est plus petit que le deuxième, zéro s'ils sont égaux, et une valeur positive si le premier est plus grand.
 

>>> cmp(2,3)

-1

>>> cmp(2,2)

0

>>> cmp(3,2)

1
 
 

Les fonction max(s), min(s).
 

Ces deux fonction permettent de sortir l'objet de plus grande et plus petite valeur d'une séquence contenant au minimum un objet.
 

La fonction apply(fonc, arg, ...).
 

Certains programmes ont besoin d'appeler des fonctions arbitrairement et ce, de manière générique, sans connaître leur nom ou argument. La forme "apply" appelle simplement la fonction passée en paramètre avec la liste d'arguments. La véritable utilité de "apply" est de pouvoir rendre l'appel de fonction différente à un même point du programme !
 
 

>>>if <test>:

>>> action, argum = f_1, (1,)

>>>else:

>>> action, argum = f_2, (2,3,4)

>>>

>>>apply(action, argum)
 

Dans cet exemple la fonction appelée change en fonction du test if !
 
 

La fonction map(fonc, liste,...).
 

Les programmes appliquent souvent une opération à chaque élément d'une liste. Python fournit une fonction interne qui effectue la plus grande partie du travail.

La fonction "map" applique une fonction passée en argument à chaque élément d'un objet séquence et retourne une liste contenant tous les résultats des appels.
 

>>> cp = [1,2,3,4]

>>> cp = map((lambda x, x+10), cp)

>>> cp

>>> [11,12,13,14]
 
 

La fonction reduce(fonc, liste, ...).
 

La fonction "reduce" nécessite au minimum deux arguments car elle travaille de façon à avoir un résultat découlant d'un objet séquence.

La fonction reduce exécute la fonction une première fois avec les deux premiers arguments (d'une liste par exemple), ensuite elle prend le résultat comme premier argument et son deuxième argument sera l'élément suivant de la liste.

Il est possible de donner un paramètre de départ à la fonction reduce. Ce qui permettra de donner la valeur de départ pour une addition successive, par exemple.
 

>>> c = (0,1,2,3,4)

>>> y = reduce(lambda x,y:x+y, c)

>>> y

10
 
 

La fonction filter(fonc, liste, ...).
 

"filter" permet de ressortir d'une liste, ou autre objet séquence, toutes les valeurs qui sont différentes de 0 après le passage dans une fonction. Il est donc, par exemple, possible de sortir les nombres impairs avec un modulo 2.
 

>>> c = [0,1,2,3,4]

>>> y = filter(lambda x: x%2, c)

>>> y

[1,3]
 
 

La fonction eval(expression, ...).
 

"eval" permet d'exécuter une chaîne comme si'l s'agissait d'une expression. On peut évaluer une expression littérale, une simple expression mathématique, et même une expression "builtin".
 

>>> eval("'x'*4")

'xxxx'

>>> eval("len('world')")

5
 
 

La fonction exec(instruction, ...).
 
 

"exec" ressemble à "eval", mais au lieu de prendre une chaîne comme une expression, exec l'exécute comme si'l s'agissait d'une instruction en python ! Ceci peut par exemple servir à faire des "import" dans une itération.
 

>>> s = ['sys', 'os', 'string', 'Tkinter']

>>> for i in s:

>>> exec 'import'+' '+i

>>>

>>> dir()

['Tkinter', '__builtins__', '__doc__', '__name__', 'i', 'os', 's', 'string', 'sys']
 
 

La fonction execfile(file, ...).
 

Execfile permet d'exécuter un programme contenu dans un fichier. C'est en un appel extérieur.
 

>>> execfile("hello.py")

"Hello World"
 

# fichier hello.py :
 

print "Hello World"