Python
Un article de Vev.
Revision as of 18 novembre 2014 à 20:58; view current revision
← Version précédente | Version suivante →
← Version précédente | Version suivante →
Sommaire |
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]]
- 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
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")
ou
message = "%s, %s ans, %s" % (nom, age, no_secu if no_secu else "pas de no de SS")
message
'Durand, 12 ans, pas de no de SS'
