Python

Un article de Vev.

Sommaire 1 variables 2 math 3 conversion 4 opérations booléennes 5 les séquences 5.1 exo 6 listes 7 instructions basiques 7.1 La fonction zip 7.2 for 7.3 exemple parenthèse 8 faire une fonction 9 sort 10 fichier 11 afficher 11.1 tous idem 12 traitement chaîne de caractères 13 Corrigés de la semaine 2 14 s3 15 module 16 temps 17 fichier 18 xxxxx 19 xxxxx

variables

_interdit_

objet_variable_simple
Objet_classe

mots clés(donc interdit en variable)
print = 1 # interdit

and 	del 	from 	not 	while
as 	elif 	global 	or 	with
assert 	else 	if 	pass 	yield
break 	except 	import 	print 	
class 	exec 	in 	raise 	
continue 	finally 	is 	return 	
def 	for 	lambda 	try

type('spam') #renvoie le type
isinstance(23, int) #test le type et renvoie si true/false

math

c = 1 + 3j #j est la partie imaginaire
c.real #affiche la partie réel
c.imag #affiche la partie imaginaire

int(4.3) #convertit un float en entier (idem autre type)

5 + 3
5 / 3 #affiche le résultat (sans le reste)
5 % 3 #affiche le reste
5 / 3.0 #affiche le résultat
5.0 // 3.0 #forcer la division entière
2 ** 32 #puissance
3 < 1 #test ici False

from math import e, pi #importe les valeurs précise de e et pi

conversion

Entier	int
Flottant	float
Complexe	complex
Chaîne	str

deux_cents = 0b11001000 ; print deux_cents
deux_cents = 0o310 ; print deux_cents
deux_cents = 0xc8 ; print deux_cents
deux_cents = int('3020', 4) ; print deux_cents #ici en base 4 il suffit de rajouter l'argument à la fonction

entier += 2 #rajoute 2 à entier puis stocke

-= *= /= #idem

liste = range(3)
print 'liste', liste
liste += ['a', 'b']
print 'aprés ajout', liste

résultat

liste [0, 1, 2]
aprés ajout [0, 1, 2, 'a', 'b']

from fractions import Fraction
Fraction(3,10) - Fraction(1,10) == Fraction(2,10)
Fraction('0.3') - Fraction('0.1') == Fraction('2/10')

from decimal import Decimal
Decimal('0.3') - Decimal('0.1') == Decimal('0.2')

opérations booléennes

x49 & y81 #ET
x49 → (0,1,1,0,0,0,1)
y81 → (1,0,1,0,0,0,1)
x49 & y81 → (0,0,1,0,0,0,1) → 17 en entier

x49 | y81 #Ou logique : opérateur |

x49 ^ y81 #Ou exclusif : opérateur ^

x49 >> 4 #décalage de 4 bits vers la gauche
x49 << 4 #décalage de 4 bits vers la droite

print "Flottant minimum", sys.float_info.min
print "Flottant maximum", sys.float_info.max

Flottant minimum 2.22507385851e-308

Flottant maximum 1.79769313486e+308

les séquences

opérations possibles

• in, not in
• + (concaténation)
• s[i] (accès par indice)
• s[i:j:k] (slicing)

le slicing (découpage de séquence)

douarnenez
0123456789
-9 -8 -7 -6 -5 -4 -3 -2 -1

>>> s = 'egg, bacon'

>>> s[0]
'e'
>>> s[9]
'n'
>>> 'g' in s
True
>>> 'h' in s
False

>>> s + 'and spam'
'egg, baconand spam'
>>> s + ' and spam'
'egg, bacon and spam'

>>> len(s)
10
>>> s.index('g')
1
>>> s.count('g')
2

>>> s*3
'egg, baconegg, baconegg, bacon'
>>> '#'*50
'##################################################'
>>> '#'*30
'##############################'
>>> s[9]
'n'
>>> s[0:3]
'egg'
>>> s[:3]
'egg'
>>> s[5:15]
'bacon'
>>> s[5:]
'bacon'
>>> s[:]
'egg, bacon'
>>> s[0:10:2]
'eg ao'
>>> s[::2]
'eg ao'
>>> s[:8:3]
'e,a'
>>> s[::3]
'e,an'
>>> s[2::3]
'gbo'
>>> s[20]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> s[5:20]
'bacon'
>>> s[15:20]
''
>>> s[-10:-7]
'egg'
>>> s[::-1]
'nocab ,gge'

exo

Exercice - niveau intermédiaire Longueur

On vous donne une chaîne composite, dont on sait qu'elle a été calculée à partir de deux chaînes inconnue et connue comme ceci:

composite = connue + inconnue + connue

L'exercice consiste à retrouver la valeur de inconnue à partir de celles de composite et connue.

from corrections.w2_slicing import connue, composite #appel à leur exercice pour charger variable

print "connue=", connue

print "composite=", composite

connue= f07dbe

composite= f07dbeef732f07dbe

À vous d'écrire du code pour retrouver inconnue à partir de composite et connue.

solution

inconnue = composite[len(connue):-len(connue)]

listes

>>> i = 4
>>> i=4
>>> a = [i, 'spam', 3.2, True]
>>> a
[4, 'spam', 3.2, True]
>>> i=44
>>> a
[4, 'spam', 3.2, True]
>>> a = [0]
>>> a = [i, 'spam', 3.2, True]
>>> a[0]
44
>>> i
44
>>> a = [i, 'spam', 3.2, True]
>>> a
[44, 'spam', 3.2, True]
>>> a[1]
'spam'
>>> a[2]
3.2
>>> a[3]
True
>>> a[0] = a[0] + 2 #rajoute 2 a l'objet 0 de la liste
>>> a
[46, 'spam', 3.2, True]
>>> a[1:3]
['spam', 3.2]
>>> a[1:2]
['spam']
>>> a[1:2] = ['egg', 'xx']  #ecrit egg et xx à la place de spam
>>> a
[46, 'egg', 'spam', 3.2, True] #cela étire la liste

>>> a[1:3] = [] #écrase la position de 1 à 3 exclus
>>> a
[46, 3.2, True]
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 10, 2) #créer une liste avec un pas de 2
[1, 3, 5, 7, 9]
>>> a
[46, 3.2, True]
>>> a.append('34') #rajoute à la liste la chaine '34'
>>> a
[46, 3.2, True, '34']

>>> a.extend([3, 5, 9]) #étend la liste
>>> a
[46, 3.2, True, '34', 3, 5, 9]

>>> a.pop() #retourne le dernier élément et le supprime
9
>>> a
[46, 3.2, True, '34', 3, 5]
>>> a.pop()
5
>>> 

instructions basiques

for entrees = [(1, 2), (3, 4), (5, 6)]
for a, b in entrees:
   print 'a', a, 'b', b

La fonction zip

villes = ["Paris", "Nice", "Lyon"]
populations = [2*10**6, 4*10**5, 10**6]

zip(villes, populations)

[('Paris', 2000000), ('Nice', 400000), ('Lyon', 1000000)]

for ville, population in zip(villes, populations):
   print population, "habitants a", ville

2000000 habitants a Paris

400000 habitants a Nice

1000000 habitants a Lyon

for

depart = [3, 7, 14, 28]

[x**2 for x in depart]

[9, 49, 196, 784]

tu écris n+p pour n de 2 a 4< pour p de 10 à 30< si n*p >= 40
[n + p for n in [2, 4] for p in [10, 20, 30] if n*p >= 40]

[22, 32, 14, 24, 34] #le 12 n'est pas pris en compte à cause du test

[[n + p for n in [2, 4]] for p in [10, 20, 30]]

[[12, 14], [22, 24], [32, 34]] #le 12 est pris en compte

exemple parenthèse

liste = [('spam',1,'a',45,2,3,Image:Cool.gif]

for indice, valeur in enumerate(liste):

    print "liste[%d] = %r" % (indice, valeur)

# ou sinon, comme enumerate renvoie une liste de tuples :

for indval in enumerate(liste):

   print "liste[%d] = %r" % indval

liste[0] = 'spam' liste[1] = 1 liste[2] = 'a' liste[3] = 45 liste[4] = 2 liste[5] = 3 liste[6] = 8 liste[0] = 'spam' liste[1] = 1 liste[2] = 'a' liste[3] = 45 liste[4] = 2 liste[5] = 3 liste[6] = 8

__________ != ___________

liste = [('spam',1,'a',45,2,3,Image:Cool.gif]

for indice, valeur in enumerate(liste):

   print "liste[%d] = %r" % (indice, valeur)

# ou sinon, comme enumerate renvoie une liste de tuples :

for indval in enumerate(liste):

   print "liste[%d] = %r" % indval

liste[0] = ('spam', 1, 'a', 45, 2, 3, Image:Cool.gif liste[0] = ('spam', 1, 'a', 45, 2, 3, Image:Cool.gif

faire une fonction

coordonnees = [(43, 7), (46, -7), (46, 0)]

def longitude(element): 
   return element[1]      #la fonction retourne le deuxieme emplacement [1]

coordonnees.sort(key=longitude)                          #argument key qui désigne une fonction
print "coordonnées triées par longitude", coordonnees

coordonnées triées par longitude [(46, -7), (46, 0), (43, 7)]

def multi_tri(listes):
   [UneListe.sort(reverse=False) for UneListe in listes]       #trie UneListe de listes à chaque boucle
   return listes

multi_tri([[40, 15, 12, 25], ['spam', 'egg', 'bacon']])

[[12, 15, 25, 40], ['bacon', 'egg', 'spam']]

def multi_tri_reverse(listes, reverses):
   "<votre_code>" 
   [UneListe.sort(reverse=R) for UneListe, R in zip(listes, reverses)]      ##trie UneListe avec la valeur R(de la liste reverses) de listes à chaque boucle

   return listes

multi_tri_reverse([[11, 2, 9], [3, 4]], (False, True))  #liste + ordre tri

[[2, 9, 11], [4, 3]]

1. retourne la liste des racine p-ièmes de l'unité

from math import e, pi

def liste_racines(p): 
    return [e**(2j*pi*n/p) for n in range (p)]      #calcule la formule pour n de (0 à p)

liste_racines(3)

[(1+0j), (-0.4999999999999998+0.8660254037844387j), (-0.5000000000000004-0.8660254037844384j)]

Entrée	Attendu	Obtenu	
2	[(1+0j), (-1+1.2246467991473532e-16j)]	[(1+0j), (-1+1.2246467991473532e-16j)]	OK
3	[(1+0j), (-0.4999999999999998+0.86602...	[(1+0j), (-0.4999999999999998+0.86602...	OK
4	[(1+0j), (6.123233995736766e-17+1j), ...	[(1+0j), (6.123233995736766e-17+1j), ...	OK

produit_scalaire: vect x.y = x1*y1 + .. + xn*yn

def produit_scalaire(X,Y): 
   """retourne le produit scalaire de deux listes de même taille"""
   "<votre_code>"
   c = [(a*b) for a, b in zip(X, Y)]     # c= le produit de la cross-list
   return sum(c[:])                      # somme de la liste

produit_scalaire([3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

795

sort

https://docs.python.org/2.7/howto/sorting.html

>>> student_tuples = [
   ('john', 'A', 15),
   ('jane', 'B', 12),
   ('dave', 'B', 10),
]
>>> sorted(student_tuples, key=lambda student: student[2])   # sort by age

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

same technique

>>> class Student:
       def __init__(self, name, grade, age):
           self.name = name
           self.grade = grade
           self.age = age
       def __repr__(self):
           return repr((self.name, self.grade, self.age))

>>> student_objects = [
   Student('john', 'A', 15),
   Student('jane', 'B', 12),
   Student('dave', 'B', 10),
]

>>> sorted(student_objects, key=lambda student: student.age)   # sort by age

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

def premier_bis(n):
   """Retourne un booléen selon que n est premier ou non
Retourne None pour les entrées négatives ou nulles"""
   # retourner None pour les entrées non valides
   if n <= 0:
       return
   # traiter le cas singulier
   if n == 1:
       return False
   # chercher un diviseur dans [2..n-1]
   for i in range(2, n):
       if n%i == 0:
           # on a trouve un diviseur
           return False
   # a ce stade c'est que le nombre est bien premier
   return True

fichier

• https://fr.wikibooks.org/wiki/Apprendre_%C3%A0_programmer_avec_Python/Les_fichiers

afficher

print "une", "seule", "ligne"
print "une", "autre",
print "ligne"

une seule ligne

une autre ligne

https://docs.python.org/2.7/library/string.html#formatstrings

age = 35
nom = "Lambert"
prenom = "Jacques"

"{}, {}, {}ans".format(nom, prenom, age)

'Lambert, Jacques, 35ans'

"{1}, {0}, {2}ans".format(nom, prenom, age)

'Jacques, Lambert, 35ans'

"{le_prenom}, {le_nom}, {l_age}ans".format(le_nom=nom, le_prenom=prenom, l_age=age)

'Jacques, Lambert, 35ans'

"{prenom}, {nom}, {age}ans".format(nom=nom, prenom=prenom, age=age)

'Jacques, Lambert, 35ans'

"{1}, {0}, {age}ans".format(nom, prenom, age=age)

'Jacques, Lambert, 35ans'

"{1}, {0}, {age}ans".format(age=age, nom, prenom)

File "<ipython-input-46-9a8e8e541bf2>", line 1
   "{1}, {0}, {age}ans".format(age=age, nom, prenom)
SyntaxError: non-keyword arg after keyword arg

from math import pi

entier = 100

"avec seulement 3 chiffres apres la virgule {:.3f} - entier {}".format(pi, entier)

'avec seulement 3 chiffres apres la virgule 3.142 - entier 100'

"avec seulement 3 chiffres apres la virgule {flottant:.3f} - entier {entier:d}".format(flottant=pi, entier=entier)

'avec seulement 3 chiffres apres la virgule 3.142 - entier 100'

"%s, %s, %sans" % (nom, prenom, age)

'Lambert, Jacques, 35ans'

variables =  {'le_nom':nom, 'le_prenom': prenom, 'l_age':age}

"%(le_nom)s, %(le_prenom)s, %(l_age)sans" % variables

'Lambert, Jacques, 35ans'

tous idem

on affiche nom age no_secu (sauf si y en a pas)

nom = "Durand"
no_secu = None
age = "12" 

____ou____ ici tous marchent

message = "{nom}, {age} ans, {secu}".format(nom=nom, age=age, secu = no_secu if no_secu else "pas de no de SS")
ou
message = "{}, {} ans, {}".format(nom, age, no_secu if no_secu else "pas de no de SS")
ou
message = nom + ", " + age + " ans, " + (no_secu if no_secu else "pas de no de SS")

message

'Durand, 12 ans, pas de no de SS'

traitement chaîne de caractères

# écrivez votre code ici
def affichage(ligne):
    "<votre_code>"
    l=ligne.replace(" ","")      #ligne est une string
    l=l.replace("\t","")         #imlpératif de changer de variable
    l=l.split(',')
    print 'liste formatée', l
    print 'lg', len(l)
    if len(l)==2:
        print '444'
        l.append("")
        l.append("??")
        print l
    if len(l)==3:
        print '333'
        l.append("??")
        print l
    if len(l)>=4:
        print '444'
        result = "N:>{nom}< P:>{prenom}< A:>{age}<".format(nom=l[1], prenom=l[0], age=l[3]) 
        print result
        return result
    else:
        print '111'
        return

affichage('Sheldon, Cooper ,')
affichage('Jules , Durand, G123, 21')
affichage('Jean')
affichage('Ted, Mosby, F321, ')

_______obtenu______
#affichage('Joseph, Dupont')	'N:>Dupont< P:>Joseph< A:>??<'
#affichage('Jules , Durand, G123, 21')	'N:>Durand< P:>Jules< A:>21<'
#affichage('Jean')	None
#affichage('Ted, Mosby, F321, ')	'N:>Mosby< P:>Ted< A:><'

Corrigés de la semaine 2

##################################################
# composite - Semaine 2 Séquence 3
##################################################
# Pour calculer inconnue, on extrait une sous-chaine de composite
# qui commence a l'index len(connue)
# qui se termine a l'index len(composite)-len(connue)
# ce qui donne en utilisant une slice
inconnue = composite [ len(connue) : len(composite)-len(connue) ]
#
# on peut aussi faire encore plus simplement
inconnue = composite [ len(connue) : -len(connue) ]


##################################################
# divisible - Semaine 2 Séquence 7
##################################################
def divisible(a, b): 
    "renvoie True si un des deux arguments divise l'autre"
    # b divise a si et seulement si le reste 
    # de la division de a par b est nul
    # et il faut regarder aussi si a divise b
    return a%b==0 or b%a==0


##################################################
# spam - Semaine 2 Séquence 7
##################################################
def spam(l):
    """
Prend en argument une liste, et retourne la liste modifiée:
 * taille paire: on intervertit les deux premiers éléments
 * taille impaire, on retire le dernier élément
"""
    # si la liste est vide il n'y a rien à faire
    if not l:
        pass
    # si la liste est de taille paire
    elif len(l)%2 == 0:
        # on intervertit les deux premiers éléments
        l[0], l[1] = l[1], l[0]
    # si elle est de taille impaire
    else:
        # on retire le dernier élément
        l.pop()
    # et on n'oublie pas de retourner la liste dans tous les cas
    return l


##################################################
# multi_tri - Semaine 2 Séquence 7
##################################################
def multi_tri(listes):
    "trie toutes les sous-listes, et retourne listes"
    for liste in listes:
        # sort fait un effet de bord 
        liste.sort()
    # et on retourne la liste de départ
    return listes


##################################################
# multi_tri_reverse - Semaine 2 Séquence 7
##################################################
def multi_tri_reverse(listes, reverses):
    """trie toutes les sous listes, dans une direction
    précisée par le second argument"""
    # zip() permet de faire correspondre les éléments 
    # de listes avec ceux de reverses
    for liste, reverse in zip(listes, reverses):
        # on appelle sort en précisant reverse=
        liste.sort(reverse=reverse)
    # on retourne la liste de départ
    return listes


##################################################
# liste_racines - Semaine 2 Séquence 7
##################################################
from math import e, pi

def liste_racines(p):
    "retourne la liste des racines p-ièmes de l'unité"
    # une simple compréhension fait l'affaire
    # souvenez vous que 1j c'est notre 'i' complexe
    return [e**((2*pi*1j*n)/p) for n in range(p)]

# Il est tout à fait possible aussi de construire les racines pas à pas
# C'est un peu moins élégant mais ça fonctionne très bien aussi
def liste_racines_bis(p):
    "retourne la liste des racines p-ièmes de l'unité"
    # on va construire le résultat petit à petit
    # en partant d'une liste vide
    resultat = []
    # pour chaque n dans {0 .. p-1}
    for n in range(p):
        # on ajoute dans le résultat la racine d'ordre n
        resultat.append(e**((2*pi*1j*n)/p))
    # et on retourne le résultat
    return resultat


##################################################
# produit_scalaire - Semaine 2 Séquence 7
##################################################
def produit_scalaire(X,Y):
    # initialisation du resultat
    scalaire = 0
    # ici encore avec zip() on peut faire correspondre 
    # les X avec les Y
    for x,y in zip(X,Y):
        scalaire += x*y
    # on retourne le résultat
    return scalaire

# Il y a plein d'autres solutions qui marchent aussi
# en voici notamment une qui utilise la fonction builtin sum
# (que nous n'avons pas encore vue, nous la verrons en semaine 4)
# en voici toutefois un avant-goût: la fonction sum est très pratique
# pour faire la somme de toute une liste de valeurs
def produit_scalaire_bis(X,Y):
    """retourne le produit scalaire de deux listes de même taille"""
    return sum([x*y for x, y in zip(X, Y)])


##################################################
# affichage - Semaine 2 Séquence 8
##################################################
# un élève a remarqué très justement que ce code ne fait pas
# exactement ce qui est demandé, en ce sens qu'avec
# l'entrée correspondant à Ted Mosby on obtient A:><
# je préfère toutefois publier le code qui est en
# service pour la correction en ligne, et vous laisse
# le soin de l'améliorer si vous le souhaitez
def affichage(s):
    # pour ignorer les espaces et les tabulations 
    # le plus simple est de les enlever
    s=s.replace(' ', '').replace('\t','')
    # la liste des mots séparés par une virgule 
    # nous est donnée par un simple appel à split
    mots = s.split(',')
    # si on n'a même pas deux mots, on retourne None
    if len(mots) < 2:
        return None
    # maintenant qu'on sait qu'on a deux mots
    # on peut extraire le prénom et le nom
    prenom = mots.pop(0)
    nom = mots.pop(0)
    # on veut afficher "??" si l'âge est inconnu
    age = "??"
    # mais si l'âge est précisé dans la ligne
    if len(mots) >= 2:
        # alors on le prend
        age = mots.pop(1)
    # il ne reste plus qu'à formater
    return "N:>{}< P:>{}< A:>{}<".format(nom, prenom, age)


##################################################
# carre - Semaine 2 Séquence 8
##################################################
def carre(s):
    # on enlève les espaces et les tabulations
    s = s.replace(' ', '').replace('\t','')
    # la ligne suivante fait le plus gros du travail
    # d'abord on appelle split() pour découper selon les ';'
    # dans le cas où on a des ';' en trop, on obtient dans le 
    #    résultat du split un 'token' vide, que l'on ignore 
    #    ici avec le clause 'if token'
    # enfin on convertit tous les tokens restants en entiers avec int()
    entiers = [int(token) for token in s.split(";") if token]
    # il n'y a plus qu'à mettre au carré, retraduire en strings,
    # et à recoudre le tout avec join et ':'
    return ":".join([str(entier**2) for entier in entiers])

s3

#exo 1


def index(extended):
    """
Prend en argument une liste, et retourne une liste modifiée:
 * indexé par l'id de chaque bateau,
 * et qui a pour valeur la liste qui décrit le bateau correspondant.

"""
    a = dict()
    #pour chaque point de la liste
    for n in range (len(extended)):
        a[extended[n][0]] = extended[n]
    return a
    #{210688000: [210688000, 49.8458, -5.1..
    #{keys: [values]}

    
index(extended)  



def merge(extended, abbreviated):
    """
Prend en argument 2 listes, et retourne une liste modifiée:
 *id -> [ nom_bateau, code_pays, position_etendu, position_abrege ]
 *dans lequel les deux objets position sont tous les deux des tuples de la forme(latitude, longitude, date_heure)

(210688000,
 [u'AMAZONITH',
  u'CY',
  (49.8458, -5.1113, u'2013-10-08T21:51:00'),
  (49.84245, -4.804717, u'2013-10-08T22:58:00')])
"""
    #on crée un dict pour abbreviated
    abbreviated_dict = dict()
    #[(abb[1],abb[2],abb[3]) for abb in abbreviated]
    for n in range (len(abbreviated)):
        abbreviated_dict[abbreviated[n][0]] = abbreviated[n][1:4]
### a utiliser tuple(abbreviated_dict[228834000])

    
    #pour chaque point de la liste
    for i in range (len(extended)):
        a[extended[i][0]] = [extended[i][4], extended[i][5], tuple(abbreviated_dict[extended[i][0]])]
    return a
    
merge(extended, abbreviated)



################### le meme autrement #######""""
def merge(extended, abbreviated):
    #tri des listes pour avoir les bateaux dans le même ordre
    extended.sort()              
    abbreviated.sort()
    
    # creation du dictionnaire en parcourant les 2 listes simultanement avec un zip
    donnees = {e[0]:[e[4],e[5],tuple(e[1:4]),tuple(a[1:4])] for (e,a) in zip(extended,abbreviated)}
    
    return donnees 


##### exo 3

def diff(extended, abbreviated):
    """On vous demande d'écrire une fonction qui retourne un tuple à trois éléments

    ext_only : l'ensemble (set) des noms des bateaux présents dans extended mais pas dans abbreviated
    ext_abb :  l'ensemble des noms des bateaux présents dans extended et dans abbreviated
    abb_only : l'ensemble des id des bateaux présents dans abbreviated mais pas dans extended
   
    """
    #faire set des id
    noms_ext = set([i[0] for i in extended])
    noms_abb = set([i[0] for i in abbreviated])
    #intersection des deux dict d'_id_
    ext_only = set(noms_ext - noms_abb)
    ext_abb = set(noms_ext & noms_abb)
    abb_only = set(noms_abb - noms_ext)
    #faire dict de la liste extended
    dict_extended = dict()
    #pour chaque point de la liste
    for n in range (len(extended)):
        dict_extended[extended[n][0]] = extended[n] #[n][0] est la clé, [n] est la valeur soit toutes la liste
    #on va rechercher dans dict_extended le nom du bateau correspondant à l'id
    resultat_ext_only = []
    for n in ext_only:
        resultat_ext_only.append(dict_extended[n][4])
    resultat_ext_abb = []
    for n in ext_abb:
        resultat_ext_abb.append(dict_extended[n][4])

    return (set(resultat_ext_only), set(resultat_ext_abb), abb_only)

module

# Pour contourner cela on peut écrire dans `main.py` quelque chose comme
# on calcule le directory où est installé le point d'entrée
import os.path
directory_installation = os.path.dirname(__file__)

# et on l'ajoute au chemin de recherche des modules
import sys
sys.path.append(directory_installation)

# maintenant on peut importer spam et eggs de n'importe où
import spam, eggs

temps

mtime_datetime = datetime.fromtimestamp(mtime_timestamp)

2014-11-25 16:01:41.339123

fichier

# de cette manière, on garantit la fermeture du fichier
with open("s1.txt", "w") as sortie:
    for i in range(2):
        sortie.write("{}\n".format(i))



Lire un contenu - bas niveau

La méthode read() permet de lire dans le fichier un buffer d'une certaine taille:


# lire dans le fichier deux blocs de 4 caractères
with open("s1.txt") as entree:
    for bloc in xrange(2):
        print "Bloc {} >>{}<<".format(bloc, entree.read(4))


Le premier bloc contient bien 4 caractères si on compte les deux sauts de ligne
Bloc1 = "0\n1\n"
Le second bloc contient quant à lui
Bloc2 = "100\n"




# on ouvre le fichier en mode 'a' comme append - ou ajouter
with open("s1.txt", "a") as sortie:
    for i in range(100, 102):
        sortie.write("{}\n".format(i))

# maintenant on regarde ce que contient le fichier
with open("s1.txt") as entree: # remarquez que sans 'mode', on ouvre en lecture seule
    for line in entree:
        # comme line contient deja la fin de ligne
        # on ajoute une virgule pour eviter une deuxieme fin de ligne
        print line,

>>> 0
>>> 1
>>> 100
>>> 101




with open("s1.txt") as entree:
    contenu = entree.read()
    print "Dans un contenu de longueur {} " \
          "on a trouvé {} occurrences de 0" \
          .format(len(contenu), contenu.count('0'))

>>> Dans un contenu de longueur 12 on a trouvé 4 occurrences de 0




import glob

# tous les fichiers .json dans le répertoire data/
for json in glob.glob("data/*.json"):
    print json


import sys
autre_stdout = open('ma_sortie.txt', 'w')
tmp = sys.stdout  # on garde un lien vers le fichier sortie standard, pour le récupérer plus tard si besoin. 
print 'sur le terminal'
sys.stdout = autre_stdout
print 'dans le fichier'
sys.stdout = tmp
print 'de nouveau sur le terminal'

xxxxx

xxxxx