|
| >>> 0x3f #entier en héxa 63 >>> 077 #entier en octale 63 >>> |
Les réels se déclarent de la manière suivant :
|
>>> x=1.3 >>> print x 1.3 >>> x=1.0 >>> print x 1.0 >>> x=float() >>> print x 0.0 >>> |
Les réels permettent aussi d'utiliser des exposants sous la forme :
>>> 3E2 300.0 >>> 3e2 300.0 >>> 3e-2 0.029999999999999999 >>>
Le type caractère n'existe pas par rapport à d'autres langages(C). la chaîne de caractères est une séquence de caractères non modifiable directement :
|
>>> var="bongour" >>> print var bongour >>> var[3]=j Traceback (most recent call last): File " NameError: name 'j' is not defined >>> var=var[0:3]+"j"+var[4:] >>> print var bonjour >>> |
Les chaînes peuvent être déclarées avec un simple guillemet :
>>> d='bonjour' >>> print d bonjour >>>
Ils peuvent aussi être avec un double guillemet, cela est utile quand nous pouvons avoir une apostrophe dans le texte rentré :
|
>>> d='bonjour' >>> print d bonjour >>> d="bonjour" >>> print d bonjour >>> d="aujourd'hui" >>> print d aujourd'hui >>> d='aujourd'hui' File " d='aujourd'hui' ^ SyntaxError: invalid syntax >>> |
L'emploi de triple guillemet est possible si nous voulons rentrer un texte sur plusieurs lignes :
|
>>> d="""ma chaîne ... est sur plusieurs ... lignes""" >>> print d ma chaîne est sur plusieurs lignes >>> |
Les tuples sont des collections de valeurs, non modifiable directement :
>>> x=(1,2) >>> x[0] 1 >>> x[0]=2 Traceback (most recent call last): File "", line 1, in ? TypeError: object doesn't support item assignment >>> x=(2,x[1]) >>> print x (2, 2) >>>
Ils peuvent être très pratique dans la sauvegarde de données, car ils peuvent contenir n'importe quel genre d'objet et ne sont pas modifiables en affectation, ce qui permet d'intégrer une certaine intégrité ou rigueur :
>>> tuples=(0,3.14,'Bonjour') >>>
Les listes
La seule différence que nous pouvons trouver avec les tuples c'est le fait que les listes sont modifiables directement avec l'indexation :
>>> L=[2,2,3,4] >>> print L [2, 2, 3, 4] >>> L[0]=1 >>> print L [1, 2, 3, 4] >>>
Les dictionnaires
Le dictionnaire est la représentation d'une liste mais indexé pour une recherche ultra rapide suivant la valeur d'indexe passé. Les valeurs ne peuvent être atteinte qu'en donnant la clé d'indexation. Un exemple va nous éclairer sur son mécanisme :
Introduction
>>> dico={1:'monpremier',2:'mondeuxieme',4:'montroisieme'}
>>> dico[1]
'monpremier'
>>> dico[3] #erreur car la clé '3' n'existe pas, il ne vas pas chercher le troisième
Traceback (most recent call last):
File "", line 1, in ?
KeyError: 3
>>> dico[4] #va chercher la valeur représenté par la clé et non le quatrième
'montroisieme'
>>>
Nous pouvons affecté un dictionnaire selon le même mécanisme :
|
>>> dico={'notemax':10,'notemin':0} >>> dico['notemax'] 10 >>> dico[1] #erreur car pas de clé nommé '1' Traceback (most recent call last): File " KeyError: 1 >>> dico['notemax']=20 #affectation car clé présente >>> print dico {'notemax': 20, 'notemin': 0} >>> dico['moyenne']=10 #ajout car clé non présente >>> print dico {'notemax': 20, 'moyenne': 10, 'notemin': 0} >>> |
Controle des flux
Les déclarations de controle de flux se font avec if, et for.Utilisez for pour énumérer les éléments d'une liste . Pour obtenir une liste de nombres , employez range(
|
lstRange = range(10) >>> print lstRange [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] for intNumber in lstRange: # Check if intNumber is one of # the numbers in the tuple. if intNumber in (3, 4, 7, 9): # "Break" terminates a for without # executing the "else" clause. break else: # "Continue" starts the next iteration # of the loop. It's rather useless here, # as it's the last statement of the loop. continue else: # The "else" clause is optional and is # executed only if the loop didn't "break". pass # Do nothing if lstRange[1] == 2: print "1 == 2" elif lstRange[2] == 3: print "3 == 4" else: print "Dunno" while lstRange[1] == 1: pass |
Fonctions
Les fonctions sont déclarées avec le mot "def". Des arguments optionnels sont ajoutés dans la déclaration de la fonction après les arguments obligatoires en leur assignant une valeur par défaut. Les fonctions peuvent retourner un tuple (et en utilisant un tuple vous pouvez effectivement avoir plusieurs valeurs en retour). Les fonctions usuelles tiennent dans une seule déclaration. Des paramètres sont passés en référence, mais des types changeants (tuples, listes, interieurs, chaines, etc) ne peuvent être modifiés :
# arg2 and arg3 sont facultatifs, ils ont leur valeur par défaut# si une des valeurs n'est pas passée (100 et "test").
def fnMyFunction(arg1, arg2 = 100, arg3 = "test"):
return arg3, arg2, arg1
ret1, ret2, ret3 = fnMyFunction("Argument 1", arg3 = "Named argument")
fnVariable = lambda x: x + 1
>>> print fnVariable(1)
2
ClassesPython supporte des formes limitées de multiple héritage dans les classes. Des variables privées et des méthodes peuvent être déclarées en ajoutant au moins deux soulignements et au moins un ( "__spam"). Nous pouvons aussi affecter des variables arbitraires pour classer des instances.
|
class MyClass: varCommon = 10 def __init__(self): self.varMyVariable = 3 def fnMyFunction(self, arg1, arg2): return self.varMyVariable # This is the class instantiation >>> clsInstance = MyClass() >>> clsInstance.fnMyFunction(1, 2) 3 # This variable is shared by all classes. >>> clsInstance2 = MyClass() >>> clsInstance.varCommon 10 >>> clsInstance2.varCommon 10 # Note how we use the class name # instead of the instance. >>> MyClass.varCommon = 30 >>> clsInstance.varCommon 30 >>> clsInstance2.varCommon 30 # This will not update the variable on the class, # instead it will create a new one on the class # instance and assign the value to that. >>> clsInstance.varCommon = 10 >>> clsInstance.varCommon 10 >>> clsInstance2.varCommon 30 >>> MyClass.varCommon = 50 # This has not changed, because varCommon is # now an instance variable. >>> clsInstance.varCommon 10 >>> clsInstance2.varCommon 50 # This class inherits from MyClass. Multiple # inheritance is declared as: # class OtherClass(MyClass1, MyClass2, MyClassN) class OtherClass(MyClass): def __init__(self, arg1): self.varMyVariable = 3 print arg1 >>> clsInstance = OtherClass("hello") hello >>> clsInstance.fnMyFunction(1, 2) 3 # This class doesn't have a .test member, but # we can add one to the instance anyway. Note # that this will only be a member of clsInstance. >>> clsInstance.test = 10 >>> clsInstance.test 10 |
ExceptionsLes exceptions sont prises en charge par Python grace aux blocks try-except [exceptionname] :
def fnExcept():
try:
# Division by zero raises an exception
10 / 0
except ZeroDivisionError:
print "Oops, invalid."
>>> fnExcept()
Oops, invalid.
Importation
Des librairies extèrieures sont utilisées avec le mot-clé [libname] keyword. Vous pouvez aussi utiliser from [libname] import [funcname] pour des fonctions seules:
import random from time import clock intRandom = random.randint(1, 100) >>> print intRandom 64
Fichier d'entrée/sortie
Python possède un tas de librairies prédéfinies. Voici un exemple de sérialisation (convertir des structures de données en chaînes en utilisant la librairie pickle ) en utilisant les fichiers I/O
|
import pickle lstList = ["This", "is", 4, 13327] # Open the file C:\binary.dat for writing. The letter r before the # filename string is used to prevent backslash escaping. flFile = file(r"C:\binary.dat", "w") pickle.dump(lstList, flFile) flFile.close() flFile = file(r"C:\text.txt", "w") flFile.write("This is a sample string") flFile.close() flFile = file(r"C:\text.txt") >>> print flFile.read() 'This is a sample string' flFile.close() # Open the file for reading. flFile = file(r"C:\binary.dat") lstLoaded = pickle.load(flFile) flFile.close() >>> print lstLoaded ['This', 'is', 4, 13327] |
Divers
Des conditions peuvent être mises sous forme de chaines. 1 < a < 3 vérifie si a est à la fois plus petit que 3 et plus grand que 1.
Vous pouvez employer del pour supprimer des variables ou des éléments dans un tableau.
Apprendre les listes est un moyen puissant de créer et de manipuler des listes. Cela consiste en une expression suivie d'une clause for suivie par zero ou par d'autres clauses if@ ou @for:
lst1 = [1, 2, 3] lst2 = [3, 4, 5] >>> print [x * y for x in lst1 for y in lst2] [3, 4, 5, 6, 8, 10, 9, 12, 15] >>> print [x for x in lst1 if 4 > x > 1] [2, 3] del lst1[0] >>> print lst1 [2, 3] del lst1
Des variables globales sont déclarées en dehors des fonctions et peuvent être lues sans déclarations spéciales , mais si vous voulez écrire à l'intérieur, vous devez les déclarer au début de la fonction avec le mot-clé "global" , sinon Python créera une variable locale et lui donnera une affectation (soyez prudent, c'est une astuce qui vous permettra de ne pas vous faire avoir:
intNumber = 5
def fnMyFunction():
# This will print 5.
print intNumber
def fnOther():
# This raises an exception because the variable has not
# been assigned to before printing. Python knows that it a
# value will be assigned to it later and creates a new, local
# intNumber instead of accessing the global one.
print intNumber
intNumber = 3
def fnYetAnother():
global intNumber
# This will correctly change the global.
intNumber = 3
