Python Les basiques

Les basiques en Python3. Mémo sur les basiques de la programmation Python3.

Importer une librairie et lister ses méthodes :

>>> import math
>>> dir (math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

Obtenir de l’aide sur une méthode :

>>> help(math.cos)
Help on built-in function cos in module math:
cos(...)
    cos(x)
    Return the cosine of x (measured in radians).
(END)

Lancer un script .py et garder la console interactive à l’issu du programme :

>>> python -i monscript.py
... script execution
>>> help(method)
>>> exit()

Entêtes des fichiers .py : il est recommandé de faire figurer ces informations en début de script. La 1ere ligne est appelée “Shebang” sous Unix. La seconde définit le chaset, l’encodage du document.

#!/usr/bin/env python2.7
# coding: utf-8

Obtenir la version de python exécutant le script :

import sys
print(sys.version[:3])
3.5

Tips : array[:n] renvoie les 3 premiers indexes (de 0 à 2 donc).

Lancer un script python :

$ python<version> monscript.py		# appel de python explicite
$ ./monscript.py			# fonctionne si le shabang est présent

Lancer un code shell depuis un script python :

import os		# import librairie
os.system('ls')		# executer la commande unix "ls"

Arguments de fonctions :

def foo(a, *args):	# *args = arguments multiples simples
    return len(args)	# retourne le nombre d'arguments optionnels

def bar(a, **kwargs):		# **kwargs = arguments multiples de type key:value
	if kwargs["foo"] == 7:	# retourne True si la clé "foo" existe et contient 7
		return True
	return False	

bar(5, boo=42, foo=7) 		# True

Méthodes utiles :

type(myObject)			# le type de l'object
isinstance(myObject, int)	# retourne True|False si l'objet et de type int
'f' in 'foo'			# retourne True car f existe dans la séquence foo
len('foo')			# longueur d'une séquence (ici 3)
min('zfoo')			# caractère le plus petit alphanumérique (ici f)
'zfoo'.index(o)			# retourne l'index de la 1ere occurence de o
'zfoo'.count(o)			# retourne le nombre d'occurence de o (ici 2)

Opérations sur les types :

>>> c = 1 + 3j		# object de type complexe (avec le j)
>>> type(c)
<class 'complex'>
>>> c.real		# partie réelle de type float
1.0
>>> c.imag		# partie entière de type float
3.0

>>> 5.2 // 3.6585	# partie entière de la division (ici en lfoat)
1.0
>>> 2 ** 3		# exposant
8

>>> 1 < 2
True
>>> 1 > 33
False

b = 0b11001000 			# 200 en binaire
o = 0o310				# 200 en octal
x = 0xc8				# 200 en hexadecimal
egg = int('3020', 4)		# 200 en base 4

Opérations sur les chaînes de caractères :

Tips : les chaînes de caractères sont immuables.
Ex: str.upper() retourne une nouvelle chaînes de caractère sans modifier str.

>>> str = """utilisé pour la doc""" 	# conserve les retours chariots

>>> str.replace(replacement, target)		# remplace target par replacement
>>> str.replace(replacement, target, 2) 	# idem avec 2 occurences maxi remplacées

>>> str = str.split()		# crée une liste composée des mots contenus dans str
>>> str = str.split(',')		# idem mais recherche la virgule comme délimiteur

>>> liste = ['foo', 'bar', 'beans']
>>> ' + '.join(liste)	# convertit en chaine de caractère avec le delimiteur
foo + bar + beans

>>> age = 35
>>>nom = "Lambert"
>>> prenom = "Jacques"
>>> "{}, {}, {}ans".format(nom, prenom, age)		# formattage paramétrique
'Lambert, Jacques, 35ans'

>>> "{1}, {0}, {2}ans".format(nom, prenom, age)	# formattage paramérique indexé
'Jacques, Lambert, 35ans'

>>> "{b}, {a}, {c}ans".format(a=nom, b=prenom, c=age)	# formattage nommé
'Jacques, Lambert, 35ans'

>>> a.strip() # supprime les espaces en début et fin ainsi que les retours chariots

>>> str.find('ref')	# retourne l'index de la 1ere occurence de de 'ref' trouvée
>>> str.rfind('ref')	# idem mais en partant de la fin de la chaîne

Opérations sur les listes :

liste = [0, 1, 2]			# creation d'une liste manuellement
liste = list(range(3))		# creation d'une liste à partir d'un objet itérable

>>> a = ['spam','egg', 42]
>>> b = ['foo', True]
>>> a[1:2] = b			# remplace l'index 1 par 2 valeurs, décallant la suite
>>> print(a)
['spam', 'foo', True, 42]
>>> a[1:2] = [b]			# remplace l'index 1 par une véritable liste
>>> print(a)
['spam', ['foo', True], True, 42]

>>> a = ['spam','egg', 'beans', 42]
>>> a[1,3] = []			# suppression de 2 indexes à partir du 1er.
>>> print(a)			# a[1,3] = '' est equivalent
['spam', 42]

>>> a = ['spam', ['foo', True], 42]
>>> a[1][0] = 'bar'
['spam', ['bar', True], 42]

>>> a = ['spam', 42]
>>> a.append([True, False])	#  ajoute l'élément à la suite dans la liste
['spam', 42, [True, False]]

>>> a = ['spam', 42]
>>> a.extend([True, False])	# ajoute les éléments 1 par 1 à la suite de la liste
['spam', 42, 3, 5, 9]

>>> a = ['spam', 42, 'foo']
>>> a.pop()				# retire le dernier element de la liste
foo
>>> print(a)
a = ['spam', 42]

>>> a = ['spam', 42, 'foo']
>>> a.pop(1)			# retire l'element à l'index spécifié
42
>>> print(a)
a = ['spam', 'foo']

>>> a = ['a','b','c','d']
>>> a.reverse()			# renverser l'ordre d'une liste
['d', 'c', 'b', 'a']

>>> a = ['a','b','c','d']
>>> a.remove(2)			# suppression d'un index
['a','b','d']			# on peut utiliser aussi : del a[2]

>>> a = ['a', 'b', 'c', 'd']
>>> a.insert(1, 'B')		# insertion à l'index spécifié (décallage du reste)
['a', 'B', 'b', 'c', 'd']

>>> 'egg'[::-1]			# renverser une séquence [debut:fin:pas]
gge
>>> 'donuts'[1:3]
on
>>> 'donuts'[1:999]
onuts
>>> 'donuts'[1::2]			# demarre à 1, jusqu'a la fin avec un pas de 2
ous
>>> 'abcdefghijklmnop'[6::-2]	# demarrer à 6 mais en reculant avec un pas de -2
geca
>>> 'donuts'[-6:-3]		# -1 correspond à la dernière lettre de la séquence
don
>>> 'donuts'[-5:-2]		# -5 correspond au o, -2 au t
onu
>>> 'donuts'[-4::]	
nuts

>>> a = [8, 7, 4, 3, 2, 9, 1, 5, 6]
>>> a.sort()			# trier numériquement
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.sort(reverse=True)		# trier en ordre inverse
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> b = ['spam', 'egg', 'bacon', 'duck']
>>> b.sort()			# trier alphabétiquement
['bacon', 'duck', 'egg', 'spam']
>>> b.sort(reverse=True)		# trier en ordre inverse
['spam', 'egg', 'duck', 'bacon']
>>> c = a + b
[9, 8, 7, 6, 5, 4, 3, 2, 1, 'bacon', 'duck', 'egg', 'spam']
>>> c.sort()
TypeError

# affectation de variables à partir des indexes d'une liste
# le nombre de variables doit être identique à la longueur de la liste
>>> liste = [1, 2, 3]
>>> gauche, milieu, droit = liste
>>> print('gauche', gauche, 'milieu', milieu, 'droit', droit)
gauche 1 milieu 2 droite 3

>>> villes = ["Paris", "Nice", "Lyon"]
>>> for i, ville in enumerate(villes):	# enumerate permet d'obtenir des indexes
>>>	  print i, ville
0 Paris
1 Nice
2 Lyon

# identique mais moins lisible qu'avec enumerate
>>> for i in range(len(villes)):
>>>     print(i, villes[i])

>>> liste = [3, 7, 14, 28]
>>> [x**2 for x in liste if x%2 == 0]	# construit une nouvelle liste en élevant
[196, 784]  				# au carré toute valeur paire.

# double imbrication d'une boucle for pour effectuer des manipulations
# 
>>> [n + p for n in [2, 4] for p in [10, 20, 30]]
[12, 22, 32, 14, 24, 34]

# code equivalent beaucoup plus lourd
>>> liste = []
>>> for n in [2, 4]:
>>>	   for t in [10, 20, 30]:
>>>		liste.append(t + n)
>>> print(liste)
[12, 22, 32, 14, 24, 34]

# utiliser une fonction de comparaison pour la méthode sort()
>>> coordonnees = [(43, 7), (46, -7), (46, 0)]
>>> def longitude(element): 
>>>    return element[1]		# retourne la longitude dans le tuple

>>> coordonnees.sort(key = longitude)		# le mot key est important
>>> print("coordonnées triées par longitude", coordonnees)
coordonnées triées par longitude [(46, -7), (46, 0), (43, 7)]

# la méthode sorted() permet de créer une copie triée, contrairement à la méthode
# sort() qui modifie 'en place' la liste d'origine.
>>> liste = [8, 7, 4, 3, 2, 9, 1, 5, 6]
>>> triee = sorted(liste, reverse=True)
>>> print('liste triée tri', triee)
>>> print('la liste initiale est intacte', liste)
liste triée tri [9, 8, 7, 6, 5, 4, 3, 2, 1]
la liste initiale est intacte [8, 7, 4, 3, 2, 9, 1, 5, 6]

Opérations sur les tuples (séquences immuables) :

>>> t = (4, 'foo', 'bar')	# creation d'un tuple immuable
>>> t = 4, 'foo', 'bar'		# idem mais sans les parenthéses
>>> t = (4,)			# creation d'un tuple avec 1 seul element
>>> t = 4,				# idem mais sans les parenthéses

>>> t = 4, 'foo', 'bar'		
>>> l = list(t)			# conversion d'un tuple en liste
[4, 'foo', 'bar']

>>> l = [4, 'foo', 'bar']		
>>> t = tuple(l)			# conversion d'une liste en tuple
(4, 'foo', 'bar')

>>> couple = (100, 'spam', 'beans')

>>> gauche = couple[0]
>>> centre = couple[1]
>>> droite = couple[2]
>>> print('gauche', gauche, 'centre', centre, 'droite', droite)
gauche 100 centre spam droite beans
# une alternative plus conventionnelle de faire la même chose (idem en javascript)
>>> gauche, centre, droite = couple
>>> print('gauche', gauche, 'centre', centre, 'droite', droite)
gauche 100 centre spam droite beans

>>> entrees = [(1, 2), (3, 4), (5, 6)]	# liste contenant des tuples
>>> for a, b in entrees:				# affectation aux variables a et b des
>>> 	   print 'a', a, 'b', b			# valeurs contenues dans chaque tuple
a 1 b 2
a 3 b 4
a 5 b 6

>>> x = [1, 2, 3]
>>> y = ['a', 'b', 'c']
>>> zipped = zip(x, y)		# itérateur de tuples concaténant les listes x et y
>>> list(zipped)			# conversion de l'itérateur en liste
[(1, 'a'), (2, 'b'), (3, 'c')]
# Remarque lorsqu'on passe à zip des listes de tailles différentes, le résultat
# est tronqué à la taille de la plus petite liste en entrée.

Objets itérables :

>>> range(1, 10, 2)
[1, 3, 5, 7, 9]

>>> liste = [1, 2, 3]
>>> it = liste.__iter__()	# obtenir l'itérateur de la liste
>>> it.__next__()			# acceder à l'element suivant
1
>>> it.__next__()
2

Opérations sur les tables de hash et les dictionnaires :

>>> dico = {'foo':42, 'bar':73}		# declaration d'un dico

>>> listeOfTuples = [('foo', 42), ('bar', 73)]
>>> dico = dict(listeOfTuples)		# autre façon d'alimenter un dico

>>> dico = dict(foo=42, bar=73)		# autre façon d'alimenter un dico

>>> dico.keys()
>>> dico.values()
>>> dico.items()		# retourne la liste de tous les tuples

>>> dico['cle']			# retourne une erreur si la clé est manquante
>>> dico.get('cle', valeurParDefaut)	# ne genere pas d'erreur et option defaut
>>> del dico[cle]			# suppression d'une entrée
>>> print('foo' in dico) 	# retourne True|False si la clé foo est trouvée

>>> annuaire = {'marc': 35, 'alice': 30, 'eric': 38}
>>> for nom, age in annuaire.items():
>>>    print("{}, age {}".format(nom, age))
alice, age 30
marc, age 35
eric, age 38

>>> from collections import OrderedDict	# dictionnaire ordonné
>>> d = OrderedDict()
>>> for i in ['a', 7, 3, 'x']: 
>>>    d[i] = i
>>> for k, v in d.iteritems():
>>>    print 'OrderedDict', k, v
OrderedDict a a
OrderedDict 7 7
OrderedDict 3 3
OrderedDict x x

Opérations sur les Set :
Les opération de soustraction (-), d’union (|) et d’intersection (&) sur les Sets sont possibles. Ex : s1 & s2 => retourne un set contenant uniquement les valeurs communes.

>>> s = {42, 73, 'spam'}		# declaration d'un set

>>> liste = [42, 42, 42, 73, 'spam']
>>> s = set(liste)			# autre façon d'alimenter. Supprime les doubons.

>>> s = frozenset(s) 		# rendre le Set immuable (ajout impossible par ex)

>>> s.add(value)			# ajout d'une entrée
>>> s.remove(value)		# supprimer l'entrée
>>> s.discard(value)		# idem
>>> s.clear()			# vider le set
>>> s.update([val1, val2])	# ajoute 2 entrées
```python
Astuces et compléments
```python
import sys
print sys.float_info	# afficher les plages max et min possibel d'un flottant
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

>>> x = True
>>> y = 12 if x else 35		# <si_vrai> if <condition> else <si_faux>

>>>	if x:
>>>		y = 12
>>>	else:
>>>		y = 35

>>> print(y)
12

>>> for x in range(1, 11):
>>>    print(x, x**2)
1 1
2 4
...
10 100

def myFunction(param):		# declaration d'une fonction
	...
	return something

>>> [ord(x) for x in 'abc']	# obtenir la lste des caractères unicode en utilisant
[97, 98, 99]			# une boucle for sur une chaine de caractères

>>> [char(x) for x in (87, 98, 99)]	# obtenir la lste des caractères ascii de la
['a', 'b', 'c']				# même manière

# utile seulement dans un terminal
>>> import readline
>>> entree = range(3)
>>> for i in range(3):
>>>    entree[i] = int(raw_input("entrez le nombre numéro {} ".format(i)))
>>> print "entree", entree

# deux listes identiques mais pas en mémoire. Ne référencent pas le même object.
>>> a = [1, 2]
>>> b = [1, 2]
>>> print '==', a == b
>>> print 'is', a is b
== True
is False

>>> id(object) 		# retourne l'identificateur mémoire de l'objet

>>> import math 		# import du module math
>>> dir(math) 		# liste toutes les methodes de math et constantes
>>> help(math.tan) 	# affiche l'aide de la méthode tan

>>> from myPackage import module1, module2	# notion de package

Tips : le package correspond à un dossier du même nom contenant les modules.py.
Le fichier init.py est obligatoire dans le package et initialise la librairie.

# une fonction python qui ne fait rien
>>> def foo():
>>>    pass		# le mot pass est utilisé aussi dans les boucles, les if|else ...

Références partagées :

On parle de référence partagée lorsque plusieurs variables pointent sur le même objet.
Le shallowcopy est utilisé pour optimiser la mémoire, mais il faut être certain de maîtriser l’outil.

>>> b = a[:]		# shallowcopy : b contient une copie de l'objet a
				# attention : on ne copie pas en profondeur !

>>> import copy
>>> b = copy.deepcopy(a)	# deepcopy : copie en profondeur tous les objets imbriqués.
>>> b = copy.copy(a)	# shallcopy : copie en surface