1+1+1
a=3
b=2
print("type de donnée :", type(a), "chaine supplémenaire")
print("addition :",a+b)
print("soustraction :", a-b)
print("multiplication :", a*b)
print("puissance :", a**b)
print("division euclidienne :",a//b)
print("reste :", a%b)
print("division :", a/b)
a=3.5
b=2.8
print("type de donnée :", type(a))
print("addition :",a+b)
print("soustraction :", a-b)
print("multiplication :", a*b)
print("puissance :", a**b)
print("division euclidienne :",a//b)
print("reste :", a%b)
print("division :", a/b)
Pour la conversion.
a=1.5
print("type :", type(a), "valeur :", a)
b=int(a)
print("type :", type(b), "valeur :", b)
c=float(b)
print("type :", type(c), "valeur :", c)
x=(1,2)
print("type de donnée :")
print(type(x), "valeur :", x)
Accès au différents éléments.
print("premier élément :", x[0])
print("deuxième élément :", x[1])
y=(1,2,3,4,5,4,3,2,1)
print(y)
y.
print("premier indexe où on à la valeur 5 :", y.index(5))
print("combien de fois a-t-on 4 :", y.count(4))
y[0]=2
liste=[1,2,3,4,5,4,3,2,1]
print("type de donnée :", type(liste))
print("valeur :", liste)
Comme pour les tuple :
print("première valeur", liste[0])
print("dernière valeur :", liste[-1])
print("découpage :", liste[1:4])
print("découpage plus fin :", liste[1::2])
print("premier indexe où on à la valeur 5 :", liste.index(5))
print("combien de fois a-t-on 4 :", liste.count(4))
Différence : structure dynamique.
print("avant :", liste)
liste.append(2)
print("après :", liste)
print("avant :", liste)
c=liste.pop()
print("après", liste)
print("et on a récupéré la valeur manquante :", c)
De nombreuses méthodes disponibles.
Utiliser la touche TAB après avoir tapé :
liste.print("avant :", liste)
liste.sort()
print("après :", liste)
print("avant :", liste)
liste.reverse()
print("après :", liste)
print("avant :", liste)
liste.extend([1.5, 1.6, 1.7, 1.8])
print("après :", liste)
print("avant :", liste)
liste.insert(2,-5)
print("après :", liste)
print("avant :", liste)
liste.remove(-5)
print("après :", liste)
tuple(liste)
On verra des techniques de construction plus élaborées au moment de la discussion des boucles.
chaine="Journée CASCIMODOT"
print("type de valeur :", type(chaine))
print("valeur :", chaine)
Comme pour les tuples et les listes.
print("découpage :", chaine[1::2])
print("première occurence du c majuscule :", chaine.index('C'))
print("nombres d'occurences de la lettre O :", chaine.count('O'))
Utilisation d'autres déclarations
chaineBis = 'Journée CASCIMODOT'
chaineTierce = """Pour inclure plusieurs lignes
cette syntaxe est particulièrement pratique
comme on peut le constater"""
print(chaineTierce)
Et pour obtenir de l'aide taper :
chaineTierce.split?ENORMEMENT de méthodes disponible.
print(chaine)
print("mise en majuscule :", chaine.capitalize())
print("remplissage avec des caractères :", chaine.center(50,'*'))
print("recherche de sous-chaine", chaine.find('née'))
print("échange :", chaine.swapcase())
print("séparation autour d'un caractère (défaut espace)", chaine.split())
Possibilité d'inclure des variables.
syntaxe beaucoup plus riche que ce qui est montré ci dessous
a=2.0000008
b=1.2
c=1.3
message='Le prochaine {0} paragraphe {0} est le numéro {0:.2}'.format(a,b,c)
print(message)
Conversions possibles.
a=int('11')
print("type :", type(a))
print("valeur :", a)
b=str(11)
print("type :", type(b))
print("valeur :", b)
chaine='abcdefghijklmnopqrstuvwxyz'
liste=list(chaine)
print("la liste est :", liste)
print('On peut la réunir :', "".join(liste))
print("En choisissant les séparateurs", "* *".join(liste))
Les listes stockent tout type de donnée.
liste=[[1,2,3], 'a', 1/5, 0.2, 12, "chaine".split()]
print(liste)
Permettent d'indexer autrement que par des entiers. Permettent de coder une correspondance.
dico={'a':2, 'b':1, 'c':5, 'd':7, 2: 3}
print('type :', type(dico))
print("valeur :", dico)
print(dico['a'])
print(dico[2])
dico = dict(((1,2),(3,4),(5,6)))
print(dico)
print(dico[1])
Nombreuses méthodes (taper dico. puis la touche de tabulation puis pour l'aide ajouter point d'interrogation).
références, affectation et unpacking+permutation
Unpacking.
a,b,c=1,2,3
print('plusieurs variables affectées en mêmes temps')
print('a :', a)
print('b :', b)
print('c :', c)
liste=[1,2,3,4]
a,b,c,d = liste
print('a :', a)
print('b :', b)
print('c :', c)
print('d :', d)
liste=('a',1,2,'b','essai')
a, *b, c=liste
print('a :', a)
print('b :', b)
print('c :', c)
Mutation et références.
a=1
b=a
print(a,b)
a=2
print(a,b)
a=[1,2,3]
b=a
print(a,b)
a=[4,5,6]
print(a,b)
a=[1,2,3]
b=a
print(a,b)
a.append(4)
print(a,b)
a=a[1:4]
print(a,b)
c=a.append(4)
print(c)
MORALITE : Pas de copie par défaut.
valeur par défaut arguments positionnels, arguments par mots clés, pass
Syntaxe élémentaire.
def maFonction(x):
y=2*x
return y
print(4)
maFonction(2)
maFonction(2.5)
maFonction((2,3))
maFonction([1,2,3])
maFonction("blabla")
Arguments par défaut.
def puissance(n, p=2):
return n**p
puissance(2,3)
puissance(3)
puissance(n=4, p=3)
puissance(p=3, n=4)
Docstring
def documentation():
"""Ceci est retournée par l'aide lorsqu'on la demande."""
pass
documentation?
Attention lorsque l'agument par défaut est mutable.
def problematique(liste=[]):
liste.append(1)
return liste
problematique()
problematique()
problematique()
def problematiqueBis(liste=None):
if liste is None:
liste=list()
liste.append(1)
return liste
problematiqueBis()
problematiqueBis()
booléens
print(type(True),type(False))
a=1
test = (a==1)
print(type(test), test)
test2 = (a<=2.0)
print(test2)
def testBateau(a):
if a==1:
print("Ok")
else:
print("pas Ok")
testBateau(1)
testBateau(2)
def testAvance(a):
if isinstance(a, type(" ")):
print("Chaine de caractére")
elif isinstance(a, type(1)):
print("Entier")
elif isinstance(a, list):
print("Liste")
else:
print("pas clair")
testAvance(1)
testAvance([1,2,3])
while¶def premier(n):
i=2
while i**2<n:
if n%i != 0:
i+=1
else:
print("Le nombre {} est composite".format(n))
print("Le nombre {} est premier.".format(n))
premier(13)
premier(100)
for¶itération généralisées, condition else
liste = ['A', 1, [1,2,3]]
for element in liste:
print(element)
uplet = (1,2,3,4,'a','b','bcd')
for element in uplet:
print(element)
Itération sur des objets plus "compliqués".
for i in range(5):
print(i)
type(range(5))
dico = {'a':1, 'b':2, 'c':3}
for indice in dico:
print(indice," : ", dico[indice])
for indice, valeur in dico.items():
print(indice, " : ", valeur)
for valeur in dico.values():
print(valeur)
Et quand on aurait besoin d'un indice.
liste= list('blablablablabla')
for i,lettre in enumerate(liste):
print("indice {0} lettre {1} :".format(i, lettre))
Discuter avantages itérateurs.
liste=[i**2 for i in range(1,10)]
for nombre in liste:
print(nombre)
liste=[i**2 for i in range(1,20) if i%3==1]
for nombre in liste:
print(nombre)
Pour les trop grosses listes.
def est_premier(nb):
for div in range(2,nb-1):
if nb%div == 0:
return False
return True
for i in (i**2 for i in range(1,20) if est_premier(i)):
print(i)
syntaxe standard par with
with open("test.txt", 'w') as aecrire:
aecrire.write("première ligne?")
aecrire.write("deuxième ligne?")
with open("test.txt", 'r') as alire:
print(alire.read())
with open("test.txt", 'a') as arajouter:
arajouter.write("\nNouvelle ligne si tout va bien")
with open("test.txt", 'r') as alire:
print(alire.read())
with open("test.txt", 'r') as alire:
for ligne in alire:
print(ligne)
Là encore un objet fichier à de multiples méthodes.
Tester avec l'autocomplétion, ne pas oublier de fermer avec la méthode close.
try except, raise
def division(num, den):
return num/den
division(1,0)
def divisionCorrige(num, den):
try:
return num/den
except ZeroDivisionError:
print("Diviser par zéro c'est mal!")
return None
divisionCorrige(1,0)
MORALE : Mieux vaut demander pardon que la permission (en temps de calcul en tout cas)
map, lambda, filter, zipreversed, sorted, slice, enumerate, formatsum, max, min, round, len, print, input, import ou from import
Exemples math, random, requests...
import math
On pourra tester l'appui de la touche TAB après avoir tapé :
math.math.exp(2)+math.sin(math.pi)
import random as rd
for i in range(5):
print(rd.random())
import copy
copy.copy()
from copy import copy
a=[1,2,3,4]
b=copy(a)
print(a,b)
a.append(5)
print(a,b)
Ordre usuel :
numpy, numba, pypy, cython, cffi)def carree(M):
n=len(M)
resultat=list()
for i in range(n):
resultat.append(list())
for j in range(n):
S=0
for k in range(n):
S+=M[i][k]*M[k][j]
resultat[i].append(S)
return resultat
M=[[1,2,3],[4,5,6],[7,8,9]]
print(M)
print(carree(M))
n=300
M=[list(range(n)) for i in range(n)]
%%timeit
carree(M)
import numpy as np
def carreeBis(M):
return M*M
def creation(n):
return np.matrix(np.tile(np.arange(n),n).reshape((n,n)))
creation(10)
M=creation(200)
%%timeit
carreeBis(M)
from numba import jit
@jit
def carreeTierce(M):
n,m=M.shape
assert n==m
resultat=np.zeros((n,n))
for i in range(n):
for j in range(n):
S=0
for k in range(n):
S+=M[i,k]*M[k,j]
resultat[i,j]=S
return resultat
M=creation(200)
%%timeit
carreeTierce(M)
Quelle librairie utiliser? exemples. urllib2/requests, matplotlib/bokeh, beautiful soup/lxml...