Teaching - 3i005


3i005 : Statistiques et Informatique

N-uplet (tuple) :

une liste d'éléments ordonnés, de longueur fixe, non mutable : aucun élément ne peut être changé après la creation du n-uplet

c = (1,2,3) # creation d un n-uplet
c[0],c[1]  # acces aux elements d un couple,
c + c  # concatenation de deux n-uplet
len(c) # nombre d element du n-uplet
a, b, c = 1, 2, 3 # affectation d un n-uplet de variables

s = set()  # creation d un ensemble
s = {1 ,2 ,1}
print(len(s)) #taille d un ensemble
s.add('s')   # ajout d un element
s.remove('s') # enlever un element
s.intersection({1,2,3,4})
s.union({1,2,3,4})

Listes :

Structure très importante en python. Il n'y a pas de tableau, que des listes (et des dictionnaires)

l = list() # creation liste vide
l1 = [ 1, 2 ,3 ] # creation d une liste avec elements
l = l + [4, 5] #concatenation
zip(l1,l2) : liste des couples
len(l) #longueur
l.append(6)     # ajout d un element
l[3]     #acces au 4-eme element
l[1:4]   # sous-liste des elements 1,2,3
l[-1],l[-2] # dernier element, avant-dernier element
sum(l)     # somme des elements d une liste
sorted(l)     #trier la liste
l = [1, "deux", 3] # une liste compposee
sub_list1 = [ x for x in l1 if x < 2] # liste comprehension
sub_list2 = [ x + 1 for x in l1 ] # liste comprehension 2
sub_list3 = [x+y for x,y in zip(l1,l1)] # liste comprehension 3

Dictionnaires :

Listes indexées par des objets (hashmap), très utilisés également. Ils permettent de stocker des couples (clé,valeur), et d'accéder aux valeurs a partir des clés (en temps efficient).

d = dict() # creation d un dictionnaire
d['a']=1   # presque tout type d objet peut etre
d['b']=2   # utilise comme cle, tout type d objet
d[2]= 'c'  # comme valeur
d.keys()   # liste des cles du dictionnaire
d.values() # liste des valeurs contenues dans le dictionnaire
d.items() # liste des couples (cle,valeur)
len(d)    #nombre d elements d un dictionnaire
d = dict([ ('a',1), ('b',2), (2, 'c')])  # autre methode pour creer un dictionnaire
d = { 'a':1, 'b':2, 2:'c'}  # ou bien...
d = dict( zip(['a','b',2],[1,2,'c']))  #et egalement...
d.update({'d':4,'e':5}) # "concatenation" de deux dictionnaires

Boucles, conditions, fonctions

Attention, en python toute la syntaxe est dans l'indentation : un bloc est formé d'un ensemble d'instructions ayant la même indentation (même nombre d'espaces précédent le premier caractère).

i=0
s=0
while i<10:  # boucle while
    i+=1     #indentation pour marquer ce qui fait parti de la boucle
    s+=i
s=0
for i in [1, 2, 3]: #boucle for
    j = 0          # indentation pour le for
    while j<i:      # boucle while
        j+=1        # deuxieme indentation pour le bloc while
        s = i + j
    s = s + s # retour a la premiere indentation, instruction du bloc for

def increment(x):   # definition d une fonction par le mot-cle def
    return x+1      # retour de la fonction

y=increment(5)      # appel de la fonction

def somme_soustraction(x,y=2):
    # possibilite de donner une valeur par defaut aux parametres
    return x+y,x-y             #  possibilite de retourner
                               #un n-uplet de valeurs,
                               # equivalent a (x+y,x-y)
xsom,xsub = somme_soustraction(10,5) #ou
res = somme_soustraction(10,5)
xsom == res[0],res[1]

Fichiers

Très simple en python :

##Lire
f=open("/dev/null","r")
print(f.readline())
f.close()

#ou plus simplement
with open("/dev/null","r") as f :
    for l in f:  
        print l

## Ecrire
f=open("/dev/null","w")
f.write("toto\n")
f.close()

#ou
with open("/dev/null","w") as f:
    for i in range(10):
        f.write(str(i))