Sommaire

Les bases

Methodes utiles pour debuger:

type(var)
dir(var)
str(var)
Cet attribut spécial vous donne les valeurs des attributs de l'instance:
ma_voiture.__dict__
{'nom': 'Ferrari'}

Voir site complet : apprendre python

Voir les conventions de syntaxe en python et règles de nommage

Voir la portée des variables et références

Pour ecrire un commentaire :

#commentaire

"""
commentaire1
commentaire2
"""

Pour afficher qqch:

print("hello")

Pour utiliser le module “builtin”:

import sys

sys.builtin_module_names
#return:
('_abc', '_ast', '_codecs', '_collections', '_functools', '_imp', '_io', '_locale', '_operator', '_signal', '_sre', '_stat', '_string', '_symtable', '_thread', '_tracemalloc', '_warnings', '_weakref', 'atexit', 'builtins', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 'posix', 'pwd', 'sys', 'time', 'xxsubtype', 'zipimport')

Pour obtenir de l’aide sur ces modules:

help("math")
help("math.tan")
#ou ceci si le module est déjà importé
help(math)
# on peut ouvrir une session d'aide
help()

Sinon il est possible d’aller voir la doc officielle sur DOC.

la fonction 2to3 permet de convertir un script Python2 en Python3.

Il est possible d’envoyer calcul en string:

print("hello", 1+1)
#return
hello 2

les calcules:

8/3
#return
2.666

8//3
#return
2

8%3
#return
2

8**2
#return
64

Les variables (attention les variables sont sensibles à la case). Python est un langage où tout est Objet comme Ruby ;p :

variable = 1
variable
#return
1

variable == 1
#return
True
variable == 2
#return
False
variable != 1
#return
False

A="2"
type(A)
#return
<class 'str'>

a=2
type(a)
#return
<class 'int'>

La concatenation :

"cou" + "cou"
#return
"coucou"

A="2"
a=2
a+A
#return
Error
a+int(A)
#return
4
str(a)+A
#return
"22"

Programmation orientée objet

Pour voir les méthodes d’une classe :

dir(str)
#return
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

"hello".capitalize()
#return
'Hello'

"hello".split("e")
#return
['h','llo']

Les listes :

l=[1,"hello",[2,3]]
type(l)
#return
<class 'list'>
l[0]
#return
1
l.index("hello")
#return
1

#inserer un element à la fin de la liste
l.append("toto")

#inserer un element à l'index 0 de la liste
l.insert(0,"titi")

#retourner le dernier element de la liste puis la retire
l.pop()

Les dictionnaires :

d = {"nom": "goku", "origine": "sayan"}
d["nom"]
#return
'goku'
d["technique"] = "kamehameha"
d
#return
{"nom": "goku", "origine": "sayan", "technique":  "kamehameha"}
del(d["technique"])
d
#return
{"nom": "goku", "origine": "sayan"}

Les conditions

La condition “if” (ne pas oublier l’indentation soit une tabulation) :

if d["nom"] == "goku":
	print("ok", d["nom"], "!")
	#ou 
	print("ok %s !" %d['nom'])
	#ou
	print("ok {0} !".format(d['nom']))
	#ou rechercher le 'nom' dans le dicto directement
	print("ok %(nom)s !" %d)
elif d["nom"] == "vegeta":
	print("ok sayan king")
else:
	print("ko")
#return
'ok goku !'

tester si var est une instance de strqui retourne un bool. assert permet de tester (et renvoie une erreur si false) :

assert isinstance(var, str)

L’iteration

La boucle “for” :

for x in d:
	print(x, " : ", d[x])
#return
nom : goku
origine : sayan

for x in d.values():
	print(x)
#return
goku
sayan

transformer les valeurs du dictionnaire en liste :

list(d.values())
#return
['goku', 'sayan']

transformer les pair (key,value) en liste :

list(d.items())
#return
[('nom', 'goku'), ('race', 'sayan')]

obtenir directement les pair (key,value) :

for k, v in d.items():
	print(k, ' : ', v)
#return
nom  : goku
race  : sayan

parcourir un iterable :

for x in [1,2,3,4]:
	print(x)
#return
1
2
3
4

for x in range(10):
	print(x)
#return
0
1
#...
9

for x in range(1, 11):
	print(x)
#return
1
2
#...
10

Les fonctions 

def creer_liste(taille):
	return list(range(taille))
	
print(creer_liste(10))
#return
[0,1...9]

creer_liste(taille=10)
#return
[0,1...9]

for x in creer_liste(10)
	print(x)
#return
0
1
#...
9

#creer un param par défaut
def creer_list(taille=10):
	return list(range(taille))
	
creer_liste()
#return
[0,1...9]

#ajouter un nombre indefini de param en dico (key,value)
def creer_liste(taille=10, **d):
	return d
	
creer_liste(taille=10, nom="goku", race="sayan")
#return
{'nom': 'goku', 'race': 'sayan'}

Les classes 

# nom du fichier "fichier.py"
class VoiturePro:
	type = "4x4"
	def vitesse()

car = VoiturePro()
print(car.type)
#return
4x4

une classe vide :

class Moto:
	"""
	classe vide
	"""

var = Moto()
var.annee = 2018
print(var.annee)
#return
2018

Quand il s’agit d’une méthode , le code appelant celle-ci va transmettre la référence de l’objet à la méthode. Il faut donc ajouter un paramètre à la méthode appelé self par convention. L’instance va envoyer la référence de l’objet via self :

class Moto:
	def vitesse_max(self):
		print("la vitesse maximum est de", self.vitesseMax)

var = Moto()
var.vitesseMax = 300
var.vitesse_max()
#return
'la vitesse maximum est de 300'

le constructeur :

class Moto:
	#le constructeur
	def __init__(self, vitesseMax, couleur):
		self.vitesseMax = vitesseMax
		self.couleur = couleur
		
	def vitesse_max(self):
		print("la vitesse maximum est de", self.vitesseMax)

var = Moto(300,"rouge")

la classe parent :

class Vehicule:
	def carburant(self):
		print("je fonctionne au caburant")

class Moto(vehicule):
	#le constructeur
	def __init__(self, vitesseMax, couleur):
		self.vitesseMax = vitesseMax
		self.couleur = couleur
		
	def vitesse_max(self):
		print("la vitesse maximum est de", self.vitesseMax)	

var = Moto(300,"rouge")
var.carburant()
#return
"je fonctionne au caburant"

Gestion des fichiers et récupération des erreurs 

try:
	f = open('fichier.txt', 'r')
	print(f.read())
except:
	print("error")
finally:
	#ce bloc s'executera dans tt les cas err ou pas
	f.close

lire ligne par ligne avec readlines() :

try:
	f = open('fichier.txt', 'r')
	for x in f.readlines():
		print(x.strip()) #enleve les char retour chariot en déb et fin de ligne
except:
	print("error")
finally:
	#ce bloc s'executera dans tt les cas err ou pas
	f.close

avoir plusieurs type d’exeptions :

try:
	f = open('fichier.txt', 'r')
	for x in f.readlines():
		print(int(x.strip())) #enleve les char retour chariot en déb et fin de ligne
except IOError as err:
	print("error de fichier", err)
except ValueError:
	print("error de conversion")
except:
	print("error unknow")
finally:
	#ce bloc s'executera dans tt les cas err ou pas
	f.close	
	
#return
#en cas de fichier inexistant, vu que la var f n'a pas été créé, cela provoquera une err

avec le bloc with (va fermer le fichier à la fin de son bloc dans tt les cas) :

try:
	with open('fichier.txt', 'r') as f
		for x in f.readlines():
			print(int(x.strip())) #enleve les char retour chariot en déb et fin de ligne
except IOError as err:
	print("error de fichier", err)
except ValueError:
	print("error de conversion")
except:
	print("error unknow")

Attention: la méthode readline lit caractère par caractère alors que la méthode readlines lit ligne par ligne.

Les modules et les paquets

Quand on créé un repertoire contenant plusieurs modules, on appelle cela un packaging.

dans la doc python2, il faut créér un fichier __init__.py dans chaque packaging même s’il est vide. Plus besoin de faire ça sur python3.

les modules sont l’equivalent des header en C (.h) :

#soit le module vehicule.py
class Vehicule:
	def carburant(self):
		print("je fonctionne au caburant")

class Moto(vehicule):
	#le constructeur
	def __init__(self, vitesseMax, couleur):
		self.vitesseMax = vitesseMax
		self.couleur = couleur
		
	def vitesse_max(self):
		print("la vitesse maximum est de", self.vitesseMax)

puis on appelle la classe Vehicule grâce à import :

#fichier main.py
import Vehicule

var = Vehicule.Moto(300,"rouge")
var.carburant()
#return
"je fonctionne au caburant"

Si le module vehicule.py est dans un dossier ex: “Transport”, pour l’appeller il faut :

#fichier main.py
import Transport.Vehicule

var = Transport.Vehicule.Moto(300,"rouge")
var.carburant()
#return
"je fonctionne au caburant"

Pour eviter des noms d’import à rallonge on peut utiliser le from import :

#fichier main.py
#soit du dossier Transport on importe Vehicule
from Transport import Vehicule

var = Vehicule.Moto(300,"rouge")
var.carburant()
#return
"je fonctionne au caburant"

Ou encore mieux :

#fichier main.py
from Transport.Vehicule import Moto

var = Moto(300,"rouge")
var.carburant()
#return
"je fonctionne au caburant"

pour recuperer le répértoire courant :

import os
os.getcwd()

pour recuperer les path python (liste de chemin où python va chercher les modules) :

import sys
sys.path

Les modules tiers

le gestionnaires de paquet distribute :

Créer un script pour accéder au web : faire une recherche google via le module python urllib

import urllib.request
import urllib.parse
import simplejson

# http://google.../q=qqch
q = urllib.parse.urlencode({ 'q' : 'wikipedia' })
url = 'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&%s' %(q)
#print(url)
search = urllib.request.urlopen(url)
json = simplejson.loads(search.read())
print(json['responseData']['results'])

Les expressions rationnelles 

import urllib.request
import urllib.parse
import simplejson
import re #regex

p = re.compile('.*youtube\.com*', re.IGNORECASE)
e = re.compile('<b>' | '</b>')

# http://google.../q=qqch
q = urllib.parse.urlencode({ 'q' : 'wikipedia' })
url = 'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&%s' %(q)
#print(url)
search = urllib.request.urlopen(url)
json = simplejson.loads(search.read())
print(json['responseData']['results'])

for r in json ['responseData']['results']:
	if p.match(r['url']):
		print(e.sub(' ', r['title'], r['url']))

La BDD

MySQLdb sur python.

installer MySQL Connector python.

pip install mysqlclient

from mysql import connector

cn = connector.connect(user='toto', password='toto', host='localhost', database='mysql')

q = 'SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES'

c = cn.cursor()
c.execute(q)

for t in c:
	print(t)

cn.close()