Python

Un article de Vev.

(Différences entre les versions)

Version du 18 novembre 2014 à 14:49

Sommaire

1 variables
2 math
3 conversion
4 opérations booléennes
5 les séquences
- 5.1 exo
6 listes
7 instructions basiques
8 faire une fonction
9 sort
10 fichier

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
3.0 #forcer la division entière // 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

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,8)]

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,8)]

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, 8) liste[0] = ('spam', 1, 'a', 45, 2, 3, 8)

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)]
   return sum(c[:])

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

795

sort

docs.python.org/2.7/howto/sorting.html//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

docs.python.org/2.7/howto/sorting.html//fr.wikibooks.org/wiki/Apprendre_%C3%A0_programmer_avec_Python/Les_fichiers

Récupérée de « http://herveleblouch.free.fr/vev/index.php/Python »