Plongez au coeur de Python

La fonction type retourne le type de données d’un objet quelconque. Les types possibles sont répertoriés dans le module types. C’est utile pour les fonctions capables de gérer plusieurs types de données.

Exemple 4.5. Présentation de type

>>> type(1)           
<type 'int'>
>>> li = []
>>> type(li)          
<type 'list'>
>>> import odbchelper
>>> type(odbchelper)  
<type 'module'>
>>> import types      
>>> type(odbchelper) == types.ModuleType
True

	type prend n’importe quel argument et retourne son type de données. Je dis bien n’importe lequel : entiers, chaînes, listes, dictionnaires, tuples, fonctions, classes, modules et même types.
	type peut prendre une variable et retourne son type de données.
	type fonctionne aussi avec les modules.
	Vous pouvez utiliser les constantes du module types pour comparer les types des objets. C’est ce que fait la fonction info, comme nous le verrons bientôt.

La fonction str convertit des données en chaîne. Tous les types de données peuvent être convertis en chaîne.

Exemple 4.6. Présentation de str

>>> str(1)          
'1'
>>> horsemen = ['war', 'pestilence', 'famine']
>>> horsemen
['war', 'pestilence', 'famine']
>>> horsemen.append('Powerbuilder')
>>> str(horsemen)   
"['war', 'pestilence', 'famine', 'Powerbuilder']"
>>> str(odbchelper) 
"<module 'odbchelper' from 'c:\\docbook\\dip\\py\\odbchelper.py'>"
>>> str(None)       
'None'

	Pour des types simples comme les entiers, il semble normal que str fonctionne, presque tous les langages ont une fonction de conversion d’entier en chaîne.
	Cependant, str fonctionne pour les objets de tout type. Ici, avec une liste que nous avons construit petit à petit.
	str fonctionne aussi pour les modules. Notez que la représentation en chaîne du module comprend le chemin du module sur le disque, la votre sera donc différente.
	Un aspect subtil mais important du comportement de str est qu’elle fonctionne pour None, la valeur nulle de Python. Elle retourne la chaîne 'None'. Nous utiliserons cela à notre avantage dans la fonction info, comme nous le verrons bientôt.

Au coeur de notre fonction info, il y a la puissante fonction dir. dir retourne une liste des attributs et méthodes de n’importe quel objet : module, fonction, chaîne, liste, dictionnaire... à peu près tout.

Exemple 4.7. Introducing dir

>>> li = []
>>> dir(li)           
['append', 'count', 'extend', 'index', 'insert',
'pop', 'remove', 'reverse', 'sort']
>>> d = {}
>>> dir(d)            
['clear', 'copy', 'get', 'has_key', 'items', 'keys', 'setdefault', 'update', 'values']
>>> import odbchelper
>>> dir(odbchelper)   
['__builtins__', '__doc__', '__file__', '__name__', 'buildConnectionString']

	li est une liste, donc dir(li) retourne la liste de toutes les méthodes de liste. Notez que la liste retournée comprend les noms des méthodes sous forme de chaînes, pas les méthoses elles-mêmes.
	d est un dictionnaire, donc dir(d) retourne la liste des noms de méthodes de dictionnaire. Au moins l’un de ces noms, keys, devrait être familier.
	C’est ici que cela devient vraiment intéressant. odbchelper est un module, donc dir(odbchelper) retourne la liste de toutes les choses définies dans le module, y compris le attributs prédéfinis comme __name__ et __doc__ et tout attribut et méthode que vous définissez. Dans ce cas, odbchelper a une seule méthode définie par l’utilisateur, la fonction buildConnectionString que nous avons étudiée au Chapitre 2.

Enfin, la fonction callable prend n’importe quel objet et retourne True si l’objet peut être appelé, sinon False. Les objets appelables sont les fonctions, les méthodes de classes ainsi que les classes elles-mêmes (nous verrons les classes au prochain chapitre).

Exemple 4.8. Présentation de callable

>>> import string
>>> string.punctuation           
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> string.join                  
<function join at 00C55A7C>
>>> callable(string.punctuation) 
False
>>> callable(string.join)        
True
>>> print string.join.__doc__    
join(list [,sep]) -> string

    Return a string composed of the words in list, with
    intervening occurrences of sep.  The default separator is a
    single space.

    (joinfields and join are synonymous)

	Les fonctions du module string sont dépréciées (bien que beaucoup de gens utilisent encore la fonction join), mais le module comprend un grand nombre de constantes utiles comme ce string.punctuation, qui comprend tous les caractères de ponctuation standards.
	string.join est une fonction qui effectue la jointure d’une liste de chaînes.
	string.punctuation n’est pas appelable, c’est une chaîne. (Une chaîne a des méthodes appelables, mais elle n’est pas elle-même appelable.)
	string.join est appelable, c’est une fonction qui prend deux arguments.
	Tout objet appelable peut avoir une doc string. En utilisant la fonction callable sur chacun des attributs d’un objet, nous pouvons déterminer les attributs qui nous intéressent (méthodes, fonctions et classes) et ce que nous voulons ignorer (constantes etc.) sans savoir quoi que ce soit des objets à l’avance.

type, str, dir et toutes les autres fonctions prédéfinies de Python sont regroupés dans un module spécial appelé __builtin__. (Il y a deux caractères de soulignement avant et deux après.) Pour vous aider, vous pouvez imaginer que Python exécute automatiquement from __builtin__ import * au démarrage, ce qui importe toutes les fonctions prédéfinies (built-in) dans l’espace de noms pour que vous puissiez les utiliser directement.

L’avantage d’y penser de cette manière est que vous pouvez accéder à toutes les fonctions et attributs prédéfinis de manière groupée en obtenant des informations sur le module __builtin__. Et devinez quoi, nous avons une fonction pour ça, elle s’appelle info. Essayez vous-même et parcourez la liste maintenant, nous examinerons certaines des fonctions les plus importantes plus tard (certaines des classes d’erreur prédéfinies, comme AttributeError, devraient avoir l’air familier).

>>> from apihelper import info
>>> import __builtin__
>>> info(__builtin__, 20)
ArithmeticError      Base class for arithmetic errors.
AssertionError       Assertion failed.
AttributeError       Attribute not found.
EOFError             Read beyond end of file.
EnvironmentError     Base class for I/O related errors.
Exception            Common base class for all exceptions.
FloatingPointError   Floating point operation failed.
IOError              I/O operation failed.

[...snip...]

	Python est fourni avec d’excellent manuels de référence que vous devriez parcourir de manière exhaustive pour apprendre tous les modules que Python offre. Mais alors que dans la plupart des langages vous auriez à vous référer constamment aux manuels (ou aux pages man, ou pire, à MSDN) pour vous rappeler l’usage de ces modules, Python est en grande partie auto-documenté.