682 lines
13 KiB
Python
Executable File
682 lines
13 KiB
Python
Executable File
# -*- coding: utf-8 -*-
|
|
#!/usr/bin/python3
|
|
"""
|
|
|
|
|
|
|
|
TP1 pour découvrir Python
|
|
|
|
La plupart des objets seront revus au cours de l'année.
|
|
Quel est l'objectif?
|
|
Apprivoiser la syntaxe du language python. Je vous propose d'exécuter les commandes suivantes et de faire le maximum d'expérience (en testant des variantes des codes proposés)
|
|
|
|
"""
|
|
############################
|
|
# Utilisation dans Pyzo #
|
|
############################
|
|
|
|
# Vous pouvez utiliser le mode interactif proposé par IEP, il suffit d'écrire le code dans le shell ouvert ci-dessus. Testez en écrivant 2+45 aprés le >>> et appuyer sur entrée. Dans le mode intéractif, les codes ne pourront pas étre conservés ....
|
|
|
|
# vous pouvez également utiliser un fichier *.py contenant un code source. Il suffit ensuite de "compiler"/ "interpréter" votre code pour que qu'il s'exécute dans le shell.
|
|
|
|
#exemple : (surligner le code é exécuter et cliquer dans l'onglet "Exécuter la selection")
|
|
|
|
####################
|
|
# Premiére étape #
|
|
####################
|
|
|
|
|
|
2+45
|
|
|
|
# Il ne se passe rien ...
|
|
|
|
print(2+45)
|
|
|
|
# N'oubliez pas la commande "print" ou faite un copier-coller dans le shell.
|
|
|
|
|
|
####################
|
|
# 1-Les entiers #
|
|
####################
|
|
|
|
|
|
|
|
print(12*45+5%3)
|
|
print(12**5)
|
|
|
|
print(7/3)
|
|
print(7//3)
|
|
print(7//3.)
|
|
print(7/3)
|
|
|
|
# Quel est le type de l'objet utilisé ?
|
|
|
|
print(type (7))
|
|
print(type (7.))
|
|
|
|
# Quelle est la différence entre 'int' et 'float'?
|
|
|
|
# Quelques mots sur la fonction id() : identificateur (unique) associé à l'objet. i.e. son adresse en mémoire.
|
|
|
|
print(id(True))
|
|
print(id(False))
|
|
print(id(2))
|
|
a=2
|
|
print(id(a))
|
|
b=a
|
|
print(id(b)==id(a))
|
|
b=3
|
|
#
|
|
a=2
|
|
b=2.0
|
|
print(id(b)==id(a))
|
|
|
|
# tester une égalité :
|
|
|
|
print(2==3)
|
|
print(2==2)
|
|
print(2==2.) # surprenant non !!
|
|
|
|
|
|
a=2
|
|
b=2
|
|
print(a is b)
|
|
print(a==b)
|
|
print(id(a))
|
|
|
|
a=2
|
|
b=2.
|
|
print(a is b)
|
|
print(a==b)
|
|
|
|
|
|
print(21%5) # Le reste de la division euclidienne....un peu de modulo. Trés utilie pour un imposer un critére de divisibilité.
|
|
|
|
|
|
|
|
# un pgcd = plus grand divisuer commun.
|
|
|
|
import fractions as frc # importer le module "fractions" sous le nom "frc" qui contient
|
|
print(dir(frc))
|
|
|
|
|
|
a=13572468
|
|
b=12345678
|
|
print(frc.gcd(a,b))
|
|
|
|
print(gcd(a,b))
|
|
|
|
|
|
from fractions import * # permet d'utiliser la fonction gcd sans le suffixe "frc".
|
|
a=13572468
|
|
b=12345678
|
|
print(gcd(a,b))
|
|
|
|
# Quelle est cette fonction "gcd"? il suffit d'ouvrir le document fractions.py pour lire la définition de gcd suivante
|
|
def gcd(a, b):
|
|
while b:
|
|
a, b = b, a%b
|
|
return a
|
|
|
|
# é relire aprés la petite partie sur les fonctions ...
|
|
|
|
|
|
### Attention: pour la culture:
|
|
|
|
print(5^2) # D'ou vient ce résultat ?
|
|
print(42^17)
|
|
# une explication rapide à méditer: l'écriture binaire de 42 est 42=1x32+0x16+1x8+0x4+1x2+0x1
|
|
# En binaire 42= 101010 et 17=10001
|
|
# 42^17=111011 (le ou exclusif)= 1x32+1x16+1x8+0x4+1x2+1x1=59
|
|
# ex : 5^2= 101^10=111=7
|
|
|
|
|
|
####################
|
|
# 2-Les flottants #
|
|
####################
|
|
|
|
print(1/3)
|
|
print(pi)
|
|
|
|
# nous aurons souvent besoin d'aide ... des bibliothéques/ des modules . Pi est défini dans la bibliothéque math.
|
|
# on appelle une commande par "math.????"
|
|
|
|
import math
|
|
print(dir(math)) # elle contient quoi?
|
|
|
|
print(math.pi)
|
|
|
|
# on peut changer le nom si nécessaire
|
|
|
|
import math as m
|
|
print(m.pi)
|
|
|
|
print(type (m.pi))
|
|
|
|
# Les fonctions usuelles
|
|
|
|
print(m.cos(2*m.pi))
|
|
print(m.sqrt(2*m.pi))
|
|
|
|
# quelques calculs avec des flottants :
|
|
|
|
print(2/3**6)
|
|
print((2/3)**6)
|
|
print((1/2**3)*2**3)
|
|
|
|
# Comment controler l'affichage ?
|
|
|
|
print(-3.445e02)
|
|
print(format(-3.445e-5,'.10f'))
|
|
print(format(m.pi,'.30f'))
|
|
|
|
|
|
##################################
|
|
# 3-Variables et affectations #
|
|
##################################
|
|
|
|
|
|
print(x)
|
|
x=5
|
|
print(x)
|
|
x:=5
|
|
print(x==4)
|
|
print(x=5)
|
|
print(x==5)
|
|
print(X) # respecter la casse
|
|
x='x'
|
|
print(x)
|
|
|
|
x=1
|
|
x=x+1
|
|
print(x)
|
|
|
|
# un test plus évolué:
|
|
|
|
x=1
|
|
y=2
|
|
x=(x+y)/2
|
|
y=(x*y)
|
|
print(x,y)
|
|
|
|
# Est-ce clair?
|
|
|
|
c=x,y,z=1,2,3
|
|
print(c)
|
|
print(x*y**z)
|
|
|
|
# De la syntaxe
|
|
|
|
s=1
|
|
s=s+1
|
|
print(s)
|
|
|
|
s=2
|
|
s+=4 # Quel est le sens de += ? (essayer -= ou *= ou **=)
|
|
print(s)
|
|
|
|
|
|
|
|
###########################
|
|
# Complément (nombres) # cette partie sera rarement utilisée ... elle est indicative.
|
|
###########################
|
|
|
|
# Les fractions
|
|
|
|
from fractions import *
|
|
a=Fraction(24,10)
|
|
print(a) # simplification !
|
|
print(a.numerator )
|
|
print(a.denominator)
|
|
|
|
a=Fraction.from_float(2.7)
|
|
print(a)
|
|
|
|
|
|
# Les complexes
|
|
|
|
z=complex(4,3)
|
|
print(z)
|
|
|
|
print(z.real)
|
|
print(z.imag)
|
|
|
|
i=complex(0,1)
|
|
print(i**2)
|
|
|
|
|
|
# pour le reste .... consulter dir(complex)
|
|
|
|
# Une premiére approche de quelques types... à approfondir et explorer
|
|
# (les listes, les Tuplets, ....)
|
|
|
|
##################################
|
|
# 4-Les listes #
|
|
##################################
|
|
|
|
a='test'
|
|
|
|
print(a)
|
|
l=[2,5,2.2, 'test']
|
|
|
|
print(l)
|
|
print(l[1])
|
|
print(l[0])
|
|
print(l[10])
|
|
print(len(l))
|
|
|
|
print(l[-1])
|
|
print(l[-5])
|
|
|
|
print(l[0:2]) # les intervalles d'entiers sont ouverts é droite
|
|
print(l[-2:2])
|
|
print(l[0:len(l)])
|
|
print(l[-3:4])
|
|
print(l[-4:4])
|
|
|
|
l[2]=15
|
|
print(l) # les listes sont mutables...
|
|
|
|
# une liste d'entiers . (Attention les intervalles sont ouverts é droite.)
|
|
|
|
I=range(2,9)
|
|
print(type(I))
|
|
# range= gamme , plage.
|
|
|
|
I=range(2,9,2)
|
|
print(list(I))
|
|
|
|
|
|
print(list(I))
|
|
print(3 in I)
|
|
|
|
# nous complèterons l'étude des listes dans le TP2
|
|
|
|
##################################
|
|
# 5-Les Tuples #
|
|
##################################
|
|
|
|
t=3,4,5,6,'7'
|
|
print(t)
|
|
|
|
print(t[0])
|
|
t[0]=1 # Attention .... les Tuples ne sont pas mutables
|
|
|
|
a,b,c=1,2,3
|
|
print(a)
|
|
|
|
a=range(2,10)
|
|
print(a[2])
|
|
|
|
|
|
##################################
|
|
# 5-Les chaînes de charactères #
|
|
##################################
|
|
|
|
a='prof de maths'
|
|
b="prof de maths"
|
|
print(a==b) # au moins c'est dit !!!
|
|
print(a is b )
|
|
|
|
print(len(a))
|
|
print(a[7:13])
|
|
print(a[-1])
|
|
|
|
a[0]='r' # Que dire des chaines?
|
|
|
|
a='il fait'
|
|
b=' chaud'
|
|
print(a+b)
|
|
|
|
c=''
|
|
c+='alpha'
|
|
print(c)
|
|
|
|
|
|
##################################
|
|
# 5-Les ensembles #
|
|
##################################
|
|
|
|
s={'je' , 2, 'vous', 34}
|
|
print(s)
|
|
|
|
print(3 in s)
|
|
print(2 in s)
|
|
|
|
a='je' in s
|
|
b='nous' in s
|
|
print(a,b)
|
|
|
|
|
|
# les ensembles sont itérables !
|
|
|
|
s={'je' , 2, 'vous', 34}
|
|
for x in s: print(x*2) # la syntaxe dans le prochaine TP
|
|
|
|
|
|
# Les opérations ensemblistes
|
|
|
|
a={1,2,3,4,5,6}
|
|
p={2,3,4,6}
|
|
i={1,3,5}
|
|
|
|
print(p&i)# l'intersection
|
|
print(p|i)# l'union
|
|
print(a-p) # no comment
|
|
|
|
|
|
# Vérification des types et changements de type
|
|
|
|
print(type('prof de maths')) # string
|
|
t=3,4,5,6,'7'
|
|
print(type(t)) # tuple
|
|
l=[2,5,2.2, 'test']
|
|
print(type(l)) # list
|
|
|
|
l=list(a)
|
|
print(l)
|
|
t=tuple(a)
|
|
print(t)
|
|
s=set(l)
|
|
print(s)
|
|
|
|
print(type(print))
|
|
|
|
|
|
##################################
|
|
# -Les dictionnaires #
|
|
##################################
|
|
|
|
|
|
d={'a':1,'b':2,'c':3}
|
|
for i in d : print(i)
|
|
|
|
for i in d : print(i, end='')
|
|
print()
|
|
|
|
print(d['a'])
|
|
print(d)
|
|
print(d.keys())
|
|
print(d.values())
|
|
print(d.items())
|
|
|
|
l=[(1,'b'),(2,'c'),(3,'g')]
|
|
print(dict(l))
|
|
|
|
#############################################################
|
|
# 5-Tester avec if / Instruction conditionelle #
|
|
#############################################################
|
|
|
|
if 2013%2==0:
|
|
print('2013 est pair')
|
|
else:
|
|
print('Sans blague ....')
|
|
|
|
if 2013%2 == 1:
|
|
print('test 1 ok ')
|
|
|
|
if ((2013%2 == 1) and (2013 > 10**3)) or (2013 < 0):
|
|
print('test 2 ok ')
|
|
|
|
if ((2013%2 == 1) and (2013 > 10**4)) or (2013 < 0):
|
|
print('test 2 ok ')
|
|
else:
|
|
print('test 2 echec ')
|
|
|
|
# Attention à la présentation indentée
|
|
|
|
if ((2013%2 == 1) and (2013 > 10**4)) or (2013 < 0):
|
|
print('test 2 ok ')
|
|
else:
|
|
print('test 2 echec ')
|
|
|
|
# et le elif
|
|
|
|
n=11
|
|
|
|
if n%3==0:
|
|
print(n,' est congru a 0 modulo 3')
|
|
elif n%3==1:
|
|
print(n,' est congru a 1 modulo 3')
|
|
else:
|
|
print(n,' est congru a 2 modulo 3')
|
|
|
|
|
|
|
|
##################################
|
|
# 6-Les fonctions #
|
|
##################################
|
|
# il s'agit d'une première approche...
|
|
# la syntaxe:
|
|
# def lenomdelafonction(variable):
|
|
#
|
|
#corps de la fonction
|
|
#
|
|
#return(le résultat)
|
|
|
|
def f(x):
|
|
return(x+1)
|
|
|
|
print(f(1))
|
|
#
|
|
def testparite(n): # le nom
|
|
res=''
|
|
if n%2==0:
|
|
res+='est pair'
|
|
else: res+='est impair'
|
|
return(n,res)
|
|
|
|
print(testparite(3) )
|
|
|
|
|
|
def puiss(x,n):
|
|
return(x**n)
|
|
|
|
|
|
puiss(11,3)
|
|
|
|
|
|
def abs(x):
|
|
if x>0:
|
|
return x
|
|
else:
|
|
return -x
|
|
|
|
print(abs(-2))
|
|
|
|
##################################
|
|
# 8-Les polynémes #
|
|
##################################
|
|
# cette partie sera très utile lors de l'oral de Math/Info du concours Centrales/Supélec mais un peu moins pendant la première année
|
|
# nécessite le module "numpy"
|
|
from numpy import *
|
|
p=poly1d([2,3,4,10]) # donne le polynéme é l'aide des coefficients
|
|
print(p)
|
|
|
|
p=poly1d([2,3,4,10], True) # donne le polynéme é l'aide des racines
|
|
print(p)
|
|
|
|
print(p.order) # le degré
|
|
print(p.roots) # les racines
|
|
print(p.coeffs) # les coefficients
|
|
|
|
print(p(5.)) # évaluation en un point
|
|
|
|
##################################
|
|
# 9-Tracer des courbes #
|
|
##################################
|
|
|
|
# Pour retrouver les codes ... vister le site http://matplotlib.sourceforge.net/gallery.html
|
|
|
|
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
# une courbe
|
|
|
|
x=np.linspace(-5,5,100) # abscisse de -5 à 5 avec 100 points
|
|
plt.plot(x,sin(x)) # on utilise la fonction sinus de Numpy
|
|
plt.ylabel('fonction sinus')
|
|
plt.xlabel("l'axe des abcisses")
|
|
plt.show()
|
|
#plt.savefig(""D:/Nicolas/Informatique/Python/MPSI/fig1.pdf") # changer le chemin
|
|
|
|
|
|
# 2 pour le prix d'une
|
|
|
|
|
|
x = np.arange(0, 10, 0.2)
|
|
y1 = np.sin(x)
|
|
y2 = np.cos(x)
|
|
# Créer une figure
|
|
fig = plt.figure()
|
|
# Un tracé dans la figure
|
|
ax = fig.add_subplot(111)
|
|
#2 tracés avec le méme axe
|
|
l1, l2 = ax.plot(x, y1, 'd', x,y2,'+')
|
|
#Légende dans le coin en haut é gauche
|
|
fig.legend((l1, l2),('sin','cos'),'upper left')
|
|
# L'axe des x est 't'
|
|
ax.set_xlabel('t')
|
|
# L'axe des y est 't'
|
|
ax.set_ylabel('y')
|
|
plt.show()
|
|
#plt.savefig("D:/Nicolas/Informatique/Python/MPSI/TPfig2.pdf")
|
|
|
|
##################################
|
|
# Divers #
|
|
##################################
|
|
|
|
|
|
# controler le temps:
|
|
|
|
import time
|
|
print(time.asctime()) # Quel est l'origine?
|
|
|
|
|
|
print(dir(time))
|
|
|
|
def d(x):
|
|
return(format(x,'.10f'))
|
|
d(m.pi)
|
|
|
|
# Que fait la fonction d?
|
|
|
|
t=time.time()
|
|
d(time.time()-t)
|
|
|
|
|
|
t=time.time()
|
|
s=0
|
|
for i in range(10**5): s=0
|
|
print(time.time()-t)
|
|
# Tester plusieurs fois la fonction précédente (les 4 lignes )
|
|
|
|
|
|
# Cmment simuler le hasard?
|
|
|
|
from random import *
|
|
|
|
print(dir(Random))
|
|
|
|
print(randint(1,6))
|
|
print(random())
|
|
|
|
|
|
# un petit jeu é tester :
|
|
print('voulez-vous jouer au dés (le temps dattente dun 6)? o/n')
|
|
r=input()
|
|
if r=='n':
|
|
print('a plus ... alors')
|
|
else:
|
|
d=0
|
|
i=0
|
|
while (d<6):
|
|
print('lance le dé')
|
|
input()
|
|
d=randint(1,6)
|
|
i+=1
|
|
if d==6:
|
|
print('tu as obtenu un ', d, ' en ', i,' etapes')
|
|
else:
|
|
print('tu as obtenu un ', d)
|
|
|
|
|
|
|
|
# question difficile é méditer (en prévision des proba !)
|
|
from random import *
|
|
from math import *
|
|
p=len([n for n in range(1000000) if hypot(random(),random())<1])
|
|
print(p/1000000*4) # ça ressemble à Pi ... non? un argument pour le justifier.
|
|
|
|
help(hypot)
|
|
|
|
# installer un module avec pip (compatible pyzo).... (inutile en TP !)
|
|
#pip install "le module"
|
|
|
|
|
|
|
|
##################################
|
|
# Quelques liens #
|
|
##################################
|
|
|
|
# pour la doc de python : http://docs.python.org/2/
|
|
# pour la doc de pyzo : http://www.pyzo.org
|
|
# pour la doc de numpy et scipy : http://docs.scipy.org/doc/
|
|
# pour la doc de matplot lib : http://matplotlib.org
|
|
# Le livre http://inforef.be/swi/download/apprendre_python3_5.pdf
|
|
|
|
|
|
|
|
|
|
##################################
|
|
# Un peu de 3D pour le fun #
|
|
##################################
|
|
|
|
|
|
|
|
## Un premier jet en 3D
|
|
|
|
from mpl_toolkits.mplot3d import Axes3D
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111, projection='3d')
|
|
|
|
u = np.linspace(0, 2 * np.pi, 100)
|
|
v = np.linspace(0, np.pi, 100)
|
|
|
|
x = 10 * np.outer(np.cos(u), np.sin(v))
|
|
y = 10 * np.outer(np.sin(u), np.sin(v))
|
|
z = 10 * np.outer(np.ones(np.size(u)), np.cos(v))
|
|
ax.plot_surface(x, y, z, rstride=4, cstride=4, color='b')
|
|
|
|
plt.show()
|
|
plt.savefig("D:/Nicolas/Informatique/Python/MPSI/TP/fig4.pdf")
|
|
## un autre exemple
|
|
|
|
from mpl_toolkits.mplot3d import axes3d
|
|
import matplotlib.pyplot as plt
|
|
from matplotlib import cm
|
|
|
|
fig = plt.figure()
|
|
ax = fig.gca(projection='3d')
|
|
X, Y, Z = axes3d.get_test_data(0.05)
|
|
ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3)
|
|
cset = ax.contour(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)
|
|
cset = ax.contour(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)
|
|
cset = ax.contour(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)
|
|
|
|
ax.set_xlabel('X')
|
|
ax.set_xlim(-40, 40)
|
|
ax.set_ylabel('Y')
|
|
ax.set_ylim(-40, 40)
|
|
ax.set_zlabel('Z')
|
|
ax.set_zlim(-100, 100)
|
|
|
|
plt.show()
|
|
plt.savefig("D:/Nicolas/Informatique/Python/MPSI/TP/fig3.pdf")
|
|
|
|
|