FAQ

FAQ

  1. A quoi sert un ``StringIO`` ?

  2. Pourquoi l'installation de pandas (ou numpy) ne marche pas sous Windows avec pip ?

  3. Python n'accepte pas les accents

  4. Qu'est-ce qu'un type immuable ou immutable ?

  5. Quel est l'entier le plus grand ?

  6. Quelle est la différence entre / et // - division ?

  7. Quelle est la différence entre return et print ?

  8. Récupérer le nom du jour à partir d'une date

  9. Récupérer le nom du mois à partir d'une date

  10. Tabulations ou espace ?

A quoi sert un ``StringIO`` ?

La plupart du temps, lorsqu’on récupère des données, elles sont sur le disque dur de votre ordinateur dans un fichier texte. Lorsqu’on souhaite automatiser un processur qu’on répète souvent avec ce fichier, on écrit une fonction qui prend le nom du fichier en entrée.

def processus_quotidien(nom_fichier) :
    # on compte les lignes
    nb = 0
    with open(nom_fichier,"r") as f :
        for line in f :
            nb += 1
    return nb

Et puis un jour, les données ne sont plus dans un fichier mais sur Internet. Le plus simple dans ce cas est de recopier ces données sur disque dur et d’appeler la même fonction. Simple. Un autre les données qu’on doit télécharger font plusieurs gigaoctets. Tout télécharger prend du temps pour finir pour s’apercevoir qu’elles sont corrompues. On a perdu plusieurs heures pour rien. On aurait bien voulu que la fonction processus_quotidien commence à traiter les données dès le début du téléchargement.

Pour cela, on a inventé la notion de stream ou flux qui sert d’interface entre la fonction qui traite les données et la source des données. Le flux lire les données depuis n’importe quel source (fichier, internet, mémoire), la fonction qui les traite n’a pas besoin d’en connaître la provenance.

StringIO est un flux qui considère la mémoire comme source de données.

def processus_quotidien(data_stream):
    # on compte toujours les lignes
    nb = 0
    for line in data_stream :
        nb += 1
    return nb

La fonction processus_quotidien fonctionne pour des données en mémoire et sur un fichier.

fichier = __file__
f = open(fichier,"r")
nb = processus_quotidien(f)
print(nb)

text = "ligne1

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.stringio, line 6)

Pourquoi l’installation de pandas (ou numpy) ne marche pas sous Windows avec pip ?

Python est un langage très lent et c’est pourquoi la plupart des modules de calculs numériques incluent des parties implémentées en langage C++. numpy, pandas, matplotlib, scipy, scikit-learn, …

Sous Linux, le compilateur est intégré au système et l’installation de ces modules via l’instruction pip install <module> met implicitement le compilateur à contribution. Sous Windows, il n’existe pas de compilateur C++ par défaut à moins de l’installer. Il faut faire attention alors d’utiliser exactement le même que celui utilisé pour compiler Python (voir Compiling Python on Windows).

C’est pour cela qu’on préfère utiliser des distributions comme Anaconda qui propose par défaut une version de Python accompagnée des modules les plus utilisés. Elle propose également une façon simple d’installer des modules précompilés avec l’instruction

conda install <module_compile>

L’autre option est d’utilser le site Unofficial Windows Binaries for Python Extension Packages qui propose des versions compilées sous Windows d’un grand nombre de modules. Il faut télécharger le fichier .whl puis l’installer avec l’instruction pip install <fichier.whl>. La différence entre les deux ooptions tient aux environnements virtuels, voir Python virtual environments.

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.information_about_package, line 17)

Python n’accepte pas les accents

Le langage Python a été conçu en langage anglais. Dès qu’on on ajoute un caractère qui ne fait pas partie de l’alphabet anglais (ponctuation comprise), il déclenche une erreur :

File "faq_cvxopt.py", line 3
SyntaxError: Non-UTF-8 code starting with 'è' in file faq_cvxopt.py on line 4, but no encoding declared;
    see http://python.org/dev/peps/pep-0263/ for details

Pour la résoudre, il faut dire à l’interpréteur que des caractères non anglais peuvent apparaître et écrire sur la première ligne du programme :

# -*- coding: latin-1 -*-

Ou pour tout caractère y compris chinois :

# -*- coding: utf-8 -*-

Si vous utilisez l’éditeur SciTE sous Windows, après avoir ajouté cette ligne avec l’encoding utf-8, il est conseillé de fermer le fichier puis de le réouvrir. SciTE le traitera différemment.

L’encodage ``utf-8`` est la norme sur Internet. C’est pourquoi il est préférable d’utiliser celui-ci pour partager son code via une page Web.

(entrée originale : classiques.py:docstring of teachpyx.examples.classiques.commentaire_accentues, line 3)

Qu’est-ce qu’un type immuable ou immutable ?

Une variable de type immuable ne peut être modifiée. Cela concerne principalement :

  • int, float, str, tuple

Si une variable est de type immuable, lorsqu’on effectue une opération, on créé implicitement une copie de l’objet.

Les dictionnaires et les listes sont modifiables (ou mutable). Pour une variable de ce type, lorsqu’on écrit a = b, a et b désigne le même objet même si ce sont deux noms différentes. C’est le même emplacement mémoire accessible paur deux moyens (deux identifiants).

Par exemple

a  = (2,3)
b  = a
a += (4,5)
print( a == b ) # --> False
print(a,b)      # --> (2, 3, 4, 5) (2, 3)

a  = [2,3]
b  = a
a += [4,5]
print( a == b ) # --> True
print(a,b)      # --> [2, 3, 4, 5] [2, 3, 4, 5]

Dans le premier cas, le type (tuple) est _immutable_, l’opérateur += cache implicitement une copie. Dans le second cas, le type (list) est _mutable_, l’opérateur += évite la copie car la variable peut être modifiée. Même si b=a est exécutée avant l’instruction suivante, elle n’a pas pour effet de conserver l’état de a avant l’ajout d’élément. Un autre exemple

a  = [1, 2]
b  = a
a [0] = -1
print(a)        # --> [-1, 2]
print(b)        # --> [-1, 2]

Pour copier une liste, il faut expliciter la demander

a  = [1, 2]
b  = list(a)
a [0] = -1
print(a)        # --> [-1, 2]
print(b)        # --> [1, 2]

La page Immutable Sequence Types détaille un peu plus le type qui sont mutable et ceux qui sont immutable. Parmi les types standards :

Une instance de classe est mutable. Il est possible de la rendre immutable par quelques astuces :

Enfin, pour les objects qui s’imbriquent les uns dans les autres, une liste de listes, une classe qui incluent des dictionnaires et des listes, on distingue une copie simple d’une copie intégrale (deepcopy). Dans le cas d’une liste de listes, la copie simple recopie uniquement la première liste

import copy
l1 = [ [0,1], [2,3] ]
l2 = copy.copy(l1)
l1 [0][0] = '##'
print(l1,l2)        # --> [['##', 1], [2, 3]] [['##', 1], [2, 3]]

l1 [0] = [10,10]
print(l1,l2)        # --> [[10, 10], [2, 3]] [['##', 1], [2, 3]]

La copie intégrale recopie également les objets inclus

import copy
l1 = [ [0,1], [2,3] ]
l2 = copy.deepcopy(l1)
l1 [0][0] = '##'
print(l1,l2)        # --> [['##', 1], [2, 3]] [[0, 1], [2, 3]]

Les deux fonctions s’appliquent à tout object Python : module copy.

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.same_variable, line 8)

Quel est l’entier le plus grand ?

La version 3 du langage Python a supprimé la constante sys.maxint qui définissait l’entier le plus grand (voir What’s New In Python 3.0). De ce fait la fonction getrandbit retourne un entier aussi grand que l’on veut.

import random,sys
x = random.getrandbits(2048)
print(type(x),x)

Qui affiche

<class 'int'> 2882159224557107513165483098383814837021447484558010147211921304219017212673656549681269862792029...

Les calculs en nombre réels se font toujours avec huit octets de précision. Au delà, il faut utiliser la librairie gmpy2. Il est également recommandé d’utiliser cette librairie pour les grands nombres entiers (entre 20 et 40 chiffres). La librairie est plus rapide que l’implémentation du langage Python (voir Overview of gmpy2).

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.entier_grande_taille, line 1)

Quelle est la différence entre / et // - division ?

Le résultat de la division avec l’opérateur / est toujours réel : la division de deux entiers 1/2 donne 0.5. Le résultat de la division avec l’opérateur // est toujours entier. Il correspond au quotient de la division.

<<<

div1 = 1 / 2
div2 = 4 / 2
div3 = 1 // 2
div4 = 1.0 // 2.0
print(div1, div2, div3, div4)  # affiche (0.5, 2.0, 0, 0)

>>>

    0.5 2.0 0 0.0

Le reste d’une division entière est obtenue avec l’opérateur %.

<<<

print(5 % 2)  # affiche 1

>>>

    1

C’est uniquement vrai pour les version Python 3.x. Pour les versions 2.x, les opérateurs / et // avaient des comportements différents (voir What’s New In Python 3.0).

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.difference_div, line 1)

Quelle est la différence entre return et print ?

La fonction print sert à afficher un résultat sur la sortie standard. Elle peut être utilisée à tout moment mais elle n’a pas d’impact sur le déroulement programme. Le mot-clé return n’est utilisé que dans une fonction. Lorsque le programme rencontre une instruction commençant par return, il quitte la fonction et transmet le résultat à l’instruction qui a appelé la fonction. La fonction print ne modifie pas votre algorithme. La fonction return spécifie le résultat de votre fonction : elle modifie l’algorithme.

(entrée originale : classiques.py:docstring of teachpyx.examples.classiques.dix_entiers_carre, line 5)

Récupérer le nom du jour à partir d’une date

<<<

import datetime
dt = datetime.datetime(2016, 1, 1)
print(dt.strftime("%A"))

>>>

    Friday

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.get_day_name, line 6)

Récupérer le nom du mois à partir d’une date

<<<

import datetime
dt = datetime.datetime(2016, 1, 1)
print(dt.strftime("%B"))

>>>

    January

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.get_month_name, line 6)

Tabulations ou espace ?

Il est préférable de ne pas utiliser les tabulations et de les remplacer par des espaces. Lorsqu’on passe d’un Editeur à un autre, les espaces ne bougent pas. Les tabulations sont plus ou moins grandes visuellement. L’essentiel est de ne pas mélanger. Dans SciTE, il faut aller dans le menu Options / Change Indentation Settings… Tous les éditeurs ont une option similaire.

(entrée originale : faq_python.py:docstring of teachpyx.faq.faq_python.entier_grande_taille, line 27)