Django 1.6 est sur les rails, et il y a des changements que j’attends depuis 3 éternités dedans.

Support officiel de Python 3

Là, on pourra dire que Python 3 est crédible. Là, on peut commencer à faire du Python 3.

Après il restera toujours Python 2 par défaut sur certains OS, donc il y a encore du chemin. Je vous rappelle qu’Ubuntu avait prévu de migrer il y a 2 ans. LOL.

Template de projet simplifié

Enfin, un nouveau projet commence avec l’admin activée par défaut.

Enfin, la base de données est configurée par défaut pour utiliser SQLite. Ca qui signifie que Django marche VRAIMENT out of the box. Un débutant à juste à commencer à coder.

C’était le dernier gros bloc à mon sens pour permettre à quelqu’un de se lancer sans avoir à chercher à comprendre comment tout marche.

Des réglages de DB moins cons

Les transactions en Django, c’était cryptique. Maintenant c’est tout simplement de l’autocommit par défaut (configurable). Et si on veut avoir plein de queries dans une seule transaction :

    with transaction.atomic():
        query1()
        query2()

Putain, enfin !

Et en prime, on peut avoir une connexion persistante à la base de données et éviter des setups à base de psycopg2_pool. Je vais jouir.

Au passage, si vous lisez la doc sur les DB, c’est plus ou moins un appel à migrer de MySQL à PostGres si vous le pouvez. Maintenant il n’y a plus que des avantages.

Autre goodies : save() fait maintenant une query au lieu de deux dans le cas d’un update. Alléluia mes frères !

Pour finir, on a un field pour stocker des données binaires brut en DB. Et la valeur de BooleanField est None (NULL en DB) par défaut, et plus False. Pas trop tôt…

Quelques bonbons

Ceux qui écrivent des backend d’authentification seront heureux d’apprendre que l’on pourra lever PermissionDenied à tout instant pour se simplifier la vie.

Les amateurs de latest() n’auront plus à faire un sort() avant pour obtenir le premier élément, il suffit de faire earliest(). Et on n’aura plus à faire un try/except sur un filter()[0] pour obtenir le premier élément, first() permet de le faire (et last() pour le dernier) et retournera None si ça foire..

Certains fields de formulaire passent en HTLM5, par exemple EmailField output type="email". Ah, les labels de forms contiennent maintenant une option suffix, qui a pour défaut “:“.

Les ModelForm peuvent écraser le message d’erreur d’un champ, sans avoir à réécrire le champ. Des dizaines de lignes qui vont sauter, yes ! De plus il n’ont plus la grosse faille de sécurité qui supposait que tous les champs du modèle (y compris l’ID) étaient exposés si on ne précisait rien. Si vous voulez ce comportement, il faudra explicitement mettre fields = "__all__".

On a reçu pas mal de mails avec des demandes d’aide, des signalements de blog down, le fait qu’on ne postait plus, etc.

Pour les demandes d’aide, je vais faire comme d’hab, c’est à dire rediriger vers l’AFPY.

Par contre pour les mails de signalement de blog down ou qui demande si on est mort car on ne postait pas trop en septembre, exceptionnellement, je vais les mettre à la poubelle. Pas par manque de respect, mais parce que je crois que les événements ont répondu à ces mails tout seul, et là on a carrément pas le temps.

Pour les autres, patientez, on met très longtemps à répondre. Ça peut prendre 3 mois. Littéralement, 3 mois. 3 fois 30 jours. Pour de vrai.

Il n’y a rien de plus facile à pirater qu’un livre. Ils ne sont pas surveillés, les DRM se cassent facilement et ils sont de taille très réduite, rendant le téléchargement aisé. Sans compter que le texte est une donnée simple d’accès.

Sachant cela, ne croyez-vous pas qu’il faille travailler un peu votre produit afin de le rendre attractif afin d’inciter les personnes à payer plutôt que de pirater ?

Et donc de répondre à ces questions :

• Pourquoi un version électronique coûte PLUS cher qu’une version papier ?
• Pourquoi un livre qui a demandé le travail de 10 / 20 personnes est 10 fois plus cher qu’un jeu smartphone qui a demandé le travail de 50 personnes sur les app stores ? L’effet d’échelle n’excuse rien dès qu’on tape dans des best sellers.
• Pourquoi traitez-vous la version numérique comme un produit secondaire à laquelle on n’apporte aucune attention (copier / coller merdique, formats de fichiers limités, pas de liens hypertextes, mise en page à l’arrache, etc) ?

N’avez-vous pas appris de la stupidité de l’industrie musicale et vidéo qui ont fait les mêmes erreurs 10 ans avant vous ?

Sortez-vous les doigts du cul.

Signé : un lecteur qui vous a déjà beaucoup rapporté de pognon et qui est prêt à payer plus.

Sinon, je viens d’acheter une Kobo Aura et je suis en train de revenir sur mon nazisme ‘tout-format-papier’. C’est vrai que c’est pas mal ce truc.

On continue avec les applications Django qui démontrent un aspect du framework, avec des sources blindées de commentaires.

Cette fois, c’est la gestion des fichiers statiques. Chopez le code quand il est encore chaud !

@+

Dans un langage fortement typé comme Python, on ne peut pas additionner des choux et des carottes, comme disait madame Germaine, ma prof de mate.

J'ai toujours eu des soucis d'intégration en cours de maths. Mon attention était discontinue et je ne me sentais pas dans mon domaine.

Par exemple on ne peut pas faire ça :

>>> 1 + "1"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Nonnnnnnnn !

Ni ça :

>>> [1] + (1,)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "tuple") to list

Pas biennnnnnnnnnnnnn !

Et pas ça :

>>> True + 1
2

OUATE ZE PHOQUE ?

Les booléens sont des entiers déguisés

Pendant longtemps, Python n’a pas eu de type bool, et on utilisait, comme en C, 0 pour faux, et 1 pour vrai. Ça marchait pas mal, mais dans un souci de rentre le langage plus propre, on a voulu créer une type spécialisé, et ainsi :

>>> type(True)
<class 'bool'>
>>> type(1)
<class 'int'>

Mais il faut avouer que pouvoir interchanger True pour 1 et False pour 0 et vice versouille, c’était achement pratique dans une discipline ou la manipulation des chiffres à des fins logiques est un peu la base du métier. Du coup il a été décidé que les booléen seraient des travs, juste une surcouche au dessus des entiers, et qu’on pourrait les utiliser en lieu et place de ceux-ci. Une exception étonnante vu la rigueur du langage sur la gestion des types.

Du coup :

>>> True == 1
True
>>> False == 0
True
>>> True + 1
2
>>> False - 1
-1

Par contre :

>>> 1 is 1
True
>>> True is True
True
>>> True is 1
False

Et qui dit exception, dit hack

Donc voici quelques moyens de détourner l’utilisation des booléens pour écrire du Perlthon…

On peut utiliser un bool pour de l’indexing ou du slicing :

>>> ('Valeur 1', 'Valeur 2')[True]
'Valeur 2'
>>> list(range(10)[True:False-1:2])
[1, 3, 5, 7]

On peut utiliser un bool pour multiplier, et l’opération multiplier marche sur les strings et les listes…

>>> "J'aime les chat" + "s" * est_pluriel
"J'aime les chat"
>>> est_pluriel = True
>>> "J'aime les chat" + "s" * est_pluriel
"J'aime les chats"
>>> def process(lst, cancel=False):
...     lst = list(lst) * (not cancel)
...     for i in lst:
...         print(i)
... 
>>> process(range(3))
0
1
2
>>> process(range(3), True)

Ou même pire, saviez-vous que la déclaration d’héritage et les clauses d’exception pouvaient inclure une expression ? En rajoutant de l’unpacking, on obtient un truc bien marrant :

>>> class Parent:
...     foo = "bar"
... 
>>> inherit = False
>>> class Enfant(*[Parent] * inherit):
...     pass
... 
>>> Enfant().foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Enfant' object has no attribute 'foo'
>>> inherit = True
>>> class Enfant(*[Parent] * inherit):
...     pass
... 
>>> Enfant().foo
'bar'
>>> catch = True
>>> try:
...     42 / 0
... except (ZeroDivisionError,) * catch:
...     print("Nope")
Nope
>>> catch = False
>>> try:
...     42 / 0
... except (ZeroDivisionError,) * catch:
...     print("Nope")
Traceback (most recent call last):
  File "<ipython-input-12-c01f7e27284d>", line 2, in <module>
    42 / 0
ZeroDivisionError: division by zero

Évidelement ça marche avec n’importe quels entiers, mais où serait le fun ?

Et on peut utiliser un bool pour incrémenter une valeur.

>>> increment = True
>>> value = 0
>>> for x in range(10):
...     value += increment
... 
>>> value
10
>>> increment = False
>>> for x in range(10):
...     value += increment
... 
>>> value
10

Voilà de quoi bien vous marrer au boulot lors de votre prochaine code review !