Catégories
Python

Python 3

Ce post fait suite à mon inscription au MOOC Python 3 sur FUN et sera donc un « aide mémoire 🧠 extended ».

Installation

Linux Debian like

sudo apt-get install python3 python3-venv python3-pip 

Windows

choco install python /y
choco install pip /y

Aide

Pour obtenir de la liste des propriété et méthodes disponibles sur un objet ou un type, il suffit de faire:

dir(monobjet)

et pour obtenir de l’aide sur une méthode donnée

help(str.startswith)

Variables & types

Les types

str : chaine de caractère (string)

bool: True (vaut 1)/ False (vaut 0)

int : entiers de précisions illimitées ; Pour caster un nombre en entier on utilise la fonction int( )

float : compris entre 10-308 et 10308 avec une précision de 12 chiffres significatifs (sys.float_info.min et sys.float_info.max)
Pour caster un nombre en float on utilise la fonction float( ) et pour éviter les erreurs d’arrondis sur:

  • des nombres rationnels (x/y), utiliser le module fraction
  • le module decimal (plus gourmand en ressources machine)

complex : entier + nombre imaginaire noté j en Python (alors qu’en math il est noté i)
Pour caster un nombre en complex on utilise la fonction complex( )

byte : binaire

list : liste de valeurs (attention, non typée)

Il est possible de formater les entier ou floats avec des _ (ex: 12_345 == 12345) pour les rendre plus lisible.

Entier en bases X

var_en_base_2 = 0b10001001               # base 2, notation binaire
bin(17) == 0b10001                       # la fonction bin( ) effectue une conversion de base 10 en binaire

var_en_base_hexadecimale = 0x10001001    # base 16

var_en_base_octale = 0o10001001          # base 8

voir doc officielle

les opérateurs

En plus des opérateur mathématique classiques, python offre les opérateurs suivants :

// : est le quotient, qui donne un entier résultant d’une division enière équivalent à un Math.floor( ) en Javascript

% : le modulo, restant de la division

** : puissance

>>> 17/5
3.4
>>> 17//5
3
>>> 17%5
2

le typage dynamique

Python est un langage a typage dynamique, c’est à dire que les variables sont du type de l’objet qui leur est affectée et donc leur type (celui des variables) peut varier dans le temps en fonction des affectations

x = 1            # x est de type int, car on lui a affecté le chiffre 1 qui est un objet de type int

x = ['a','b']    # type(x) == list

on a 2 fonctions utiles à déterminer le type d’un objet type( ) et isinstance( ) :

type(x)                  # retourne int, str, list etc.

isinstance(x, int)       # retourn True ou False

Depuis python-3.5, il est possible d’ajouter des annotations de type à utiliser avec des outils comme mypy.

Entrées/sortie de base

Pour récupérer une saisie utilisateur et l’afficher on utilise les fonction input( ) et print( )

chiffre_saisi = input("saisi un chiffre, por favor ? ")

print(f"le chiffre saisi est {int(chiffre_saisi)}")      #  si autre chose qu'un entier est saisi, cela lève une exception: ValueError: invalid literal for int()

note: cette notation  print(f »… a été introduite en python 3

Séquences

opérations de base possibles sur les séquences

Il est possible d’appliquer un ensemble d’opérations de bases aux séquences.
Pour les exemples suivants, ces opérations sont appliquées à une chaine de caractère qui est un type particulier de séquence:

seq ='behrouze'

seq[3]                      # 'r' on récupère l’élément d'index spécifié

'beh' in seq                # True test d'appartenance
'beh' not in seq            # False

'be' 'hrou' == 'be'+'hrou'  # 'behrou' concaténation 

len(seq)                    # 8 nombres d'éléments de la séquence 

seq.index('e')              # position de la 1ère occurrence de l'élément spécifié

count('e')                  # 2 nombres d’occurrences de l'élément spécifié

min(seq)                    # 'b'
max(seq)                    # 'z'

seq * 3                     # shallow copy, retourne ici 3 fois la séquence

slice

Il est possible de découper une séquence simplement grâce aux [ ] d’index, c’est l’opération de slicing dans laquelle on peut spécifier (optionnel) les début, fin et pas .

machaine[debut:fin:pas]

A noter que :

  • l’élément début est inclus, alors que l’élément fin est exclu
  • des début, fin et pas négatifs peuvent être spécifiés
  • une même séquence sera indexée dans les 2 sens, c’est à dire de [0:n] et de [-(n+1): -1] par Python, cela signifie que :
    seq ='behrouze'   # pour info len(seq) == 8
    
    seq[1:4] == seq[-7:4] == seq[-7:-4] == 'ehr'
  • un pas négatif, indique que le parcours de la séquence se fait de la droite vers la gauche

Les listes

Les listes sont des séquences qui stockent des références vers des objets en mémoire, ils ne stockent pas ces objets et sont mutables (ex les méthodes comme sort( ) modifient directement la liste, mais attention retourne nul).

Il est possible de manipuler les listes en leurs affectant des éléments :

seq = ['behrouze',5, False]

seq[1] = True                  # remplacement ['behrouze', True, False]

seq[1:2] = [888, 'toto']       # affectation sur un slice ['behrouze', 888, 'toto', False]

del seq[:1]                    # équivalent à un seq[:1] = [] => [888, 'toto', False]

seq.append('behrouze')         # [888, 'toto', False, 'behrouze']

seq.extend(['aaa', 78, 'bbb']) # [888, 'toto', False, 'behrouze', 'aaa', 78, 'bbb']

à étudier les autres méthodes dispo par un dir(list)  puis help(list.lamethodeaetudier)

String et Lists

Pour passer d’une chaine de caractère à une liste (pour y effectuer des opération) puis repasser en string, on peut utiliser la mécanique suivante str.spli(‘ ‘) puis ‘ ‘.join(list):

mastring = 'toto aime le choco'
maliste = mastring.split(' ')      # ['toto', 'aime', 'le', 'choco']
maliste[1] = maliste[1].upper()    # ['toto', 'AIME', 'le', 'choco']
mastring = ' '.join(maliste)       # 'toto AIME le choco'

Compréhensions de liste

Les compréhensions de liste, en anglais « list comprehensions » sont du sucre syntaxique pour rendre plus concis et lisible, les structures itératives avec condition:

ma_nouvelle_liste = [function(x) for x in ma_liste if condition(x)]

Tuples

Un Tuple est un objet de type séquence mais contrairement à l’objet List elle est immuable et on les déclare de la façon suivante:

mon_tuple = 1,2       # à noter que 1,2 == 1,2, == (1,2) == (1,2,)

Il est possible d’additionner des tuples:

tuple1 = (1,)
tuple2 = (2, 'toto', 3)
tuple3  == (1, 2, 'toto', 3)   # tuple3 = tuple1 + tuple2

Tuples et Lists

Il est possible de caster une liste en Tuple et inversement avec les builtin functions list et tuple

list(tuple3) == [1, 2, 'toto', 3]
tuple([1, 2, 'toto', 3]) == tuple3

Sequence unpaking

(TODO)

Fonctions

En Python, les blocs d’instructions sont définis grâce à l’indentation (de 4 espaces), ce qui nous sert pour les blocs d’instructions compris dans des if/else ou dans des boucles for, mais aussi lors de la définition de fonctions:

def ma_fonction_qui_affiche_qqchose(x):

    print(f"voilà quelque chose: {x}")

Modules

Un module est un fichier Python qui peut être importé sous la forme d’un objet Module dans un autre fichier Python et qui met à disposition un certain nombre de fonctionnalités.

Python dispose d’une bibliothèque standard de modules installés par défaut, mais il en existe bien d’autres.

Fichiers

Ouvrir un fichier

ouvrir un fichier à l’ancienne

On utilise la fonction open pour ouvrir les fichiers et obtenir un objet de type fichier sur lequel on peut utiliser des méthodes de lecture (read), écriture (write) recherche (seek) etc.

fichier = open(r'C:\temp\monfichier.txt', 'w', encoding='utf-8')
...
fichier.close()       # ne pas oublier de TOUJOURS fermer le fichier
  • le 1er argument de la fonction est précédé d’un r (sous Windows) pour ne pas avoir à doubler les antislash (\\) car \n \t etc sont des caractères spéciaux
  • le 2ème argument spécifie le mode d’ouverture du fichier :
    • r : read
    • w : write
    • r+ : read + write
    • a : append
    • b : binaire pour la manipulation de bytes (images, audio, exe etc.)

ouvrir un fichier avec le context manager

L’instruction with permet d’encapsuler l’exécution du bloc de code suivant pour utiliser un context manager qui implémente le pattern try..except..finally et appel automatiquement la méthode close( ) même en cas de survenue d’une exception (lire à ce sujet).

with open('foo.txt', 'w', encoding='utf-8') as fichier:
    for i in range(2):
        fichier.write(f"{i}\n")

Cela évite de laisser des fichiers ouverts et dans un état inconsistant.

Attention, un objet fichier est un itérateur et n’est donc parcourable qu’une seule fois, pour le parcourir plusieurs fois, il faudra le fermer et le ré-ouvrir.

utilitaires

Avant Python 3.4 il fallait utiliser les module os et glob pour disposer d’utilitaires pour travailler dans un système de fichiers, depuis a été introduit le module pathlib pour moderniser (OO) et regrouper toutes les fonctionnalités relatifs aux manipulations de dossiers/fichiers dans un même module. La classe principale étant la classe Path.

La manipulations de fichiers de type JSON, CSV, XML se fait via des modules dédiés.

Liens

tuto officiel Python pour débutant

conventions de nommage en Python

mots clé réservés du language