PROJET AUTOBLOG


Sam & Max: Python, Django, Git et du cul

Site original : Sam & Max: Python, Django, Git et du cul

⇐ retour index

Les stats Sam&Max 2013

samedi 28 décembre 2013 à 14:02

Presque 2 ans déjà que ce blog prêche la bonne parole aux brebis égarées ici bas. Comme tout webmaster qui se respecte on adore les stats alors on va se faire un petit résumé de l’année 2013 dans la joie et la bonne humeur. On avait déjà publié quelques stats ici d’ailleurs l’été dernier.

Pour info sur l’année 2012 le blog totalisait 244,183 visites.

Petit récap année 2013:

Date de création: 4 février 2012
Visites pour l’année 2013: 1,173,671
Visites depuis la création du blog: 1,417,854
Nombre de posts: 323
Nombre de commentaires: 5967

Qui nous envoi du monde ?

Search Engines 481,053
Twitter 20,139
news.humancoders.com 9,702
sebsauvage.net 8,837
Facebook 6,072
Netvibes 4,727
multiboards.net 4,465
google.fr 1,366
macg.co 1,257
search.free.fr 1,129
Google Reader 897
Google+ 837
lehollandaisvolant.net 678

Par quels mots-clefs les gens sont arrivés ici ?
(Comme il y en a trop la liste est volontairement tronquée)

masturbation feminine 19,981
masturbation féminine 8,896
fkk 6,504
masturbation 6,362
video masturbation 3,789
masturbation video 3,272
masturbation femme 2,403
maison close allemagne 2,105
freeplug 1,904
synchroniser freeplug 1,641
video masturbation feminine 1,427
masturbation feminine video 1,328
sam et max 1,197
fkk allemagne 1,118
synchronisation freeplug 965
sex japon 868
sexe japonais 813

Les posts les plus vus:

Home page / Archives 268,964
Masturbation féminine – Un peu de théorie en vidéo 160,715
Une journée dans un FKK (maison close Allemande) 65,974
Synchroniser les freeplugs (les adaptateurs réseaux CPL de free) 43,321
Les abréviations de la prostitution et des Escorts, vous connaissez ? 33,502
Les Japonais et le sexe – des gros malades… Ou pas… 17,011
Les émoticones cachées de Skype 15,244
Il ne faut pas prendre les gens pour des cons mais ne jamais oublier qu’ils en sont 14,666
10 astuces pour Sublime Text 2 12,716
Ajouter un chemin à la variable d’environnement PATH sous Windows 9,309
Les articles pour apprendre Python, dans le bon ordre :-) 8,188
Liste des plugins sublime text que j’utilise 7,514
Cours et tutos 6,415
L’encoding en Python, une bonne fois pour toute 5,532
Les environnements virtuels Python : virtualenv et virtualenvwrapper 5,423
Entreprendre en France, Autopsie d’un échec. 5,204
Bitcoin: créer un portefeuille, obtenir des bitcoins et payer 5,138
La fonction anonyme appelée immédiatement en Javascript: (function())() 4,933
Mettre la capote sans casser l’ambiance 4,333
Nos tweets 4,137
Qu’est-ce que Javascript et à quoi ça sert ? 4,073
Soyez relax, faites vous un petit Git stash 3,976
Tiens, je suis toujours sur OSX 3,891
Comment tailler une pipe 3,786
Qu’est-ce qu’on peut faire avec Python ? 3,705
Votre Python aime les pip 3,688
Qu’est-ce que bitcoin ? 3,609

Flattr nous rapporte un peu de pognon mais j’ai pas les stats actuellement (c’est sam qui tiens les bourses…). On s’en est toujours pas servi je crois d’ailleurs.

Cela nous fait quand même à peu près 1 200 000 visites dans l’année. Comprenez que des fois ce petit VPS avec 512MO de RAM que nous louons soit un peu essouflé.

Passez de bonnes fêtes ou ouvrez-vous bien les veines (toujours dans le sens des fibres)

flattr this!

Retrait de l’article sur Rapydscript

vendredi 27 décembre 2013 à 17:15

L’article invité sur Rapydscript a été retiré par l’auteur. Il a en effet reçu quelques remarques sur les photos entourant l’article sur la page d’accueil ^^

J’en profite pour rappeler que les auteurs des articles invités peuvent bien entendu retirer les articles qu’ils veulent, les éditer, et mettre un lien vers à peu près tout ce qu’ils souhaitent dedans.

Ils n’ont aucune obligation envers nous et nous leur sommes reconnaissant d’avoir pris le temps de poster sur Sam et Max.

N’oubliez cependant pas que sur le blog il y aura toujours des trucs Not Safe For Work Anything. Donc prenez un bon pseudo et faites gaffes à ceux à qui vous passez les liens :-)

P.S: l’articl est bien entendu toujours disponible sur les autoblogs puisque nous n’avons pas contrôle dessus et que les articles sont publiés sous licence creative common.

flattr this!

Le PEP8, en résumé

jeudi 26 décembre 2013 à 20:15

Internet, c’est la culture du TL;DR, donc plutôt je vais faire une petite synthèse des trucs les plus importants du PEP8, comme ça si vous avez la flemme de le lire, au moins vous aurez l’essentiel.

Ce texte liste les règles stylistiques recommandées, invitant toute la communauté Python à écrire un code de la même façon.

Je vais également y ajouter des éléments de style qui ne sont pas dedans, mais que j’ai pu constater comme étant les choix les plus courants dans les sources que j’ai pu lire.

Espaces

Les opérateurs doivent être entourés d’espaces.

Il faut faire ceci :

variable = 'valeur'
 
ceci == cela
 
1 + 2

Et non:

variable='valeur'
 
ceci==cela
 
1+2

Il y a deux exceptions notables.

La première étant qu’on groupe les opérateurs mathématiques ayant la priorité la plus haute pour distinguer les groupes :

a = x*2 - 1
b = x*x + y*y
c = (a+b) * (a-b)

La seconde est le signe = dans la déclaration d’arguments et le passage de paramètres :

def fonction(arg='valeur'): #  ça c'est ok
    pass
 
resultat = fonction(arg='valeur') #  ça aussi

On ne met pas d’espace à l’intérieur des parenthèses, crochets ou accolades.

Oui :

2 * (3 + 4)
 
def fonction(arg='valeur'):
 
{str(x): x for x in range(10)}
 
val = dico['key']

Non :

2 * ( 3 + 4 )
 
def fonction( arg='valeur' ):
 
{ str(x): x for x in range(10) }
 
val = dico[ 'key' ]

On ne met pas d’espace avant les deux points et les virgules, mais après oui.

Oui :

def fonction(arg1='valeur', arg2=None):
 
dico = {'a': 1}

Non :

def fonction(arg='valeur' , arg2=None) :
 
dico = {'a' : 1}

Lignes

Une ligne doit se limiter à 79 charactères. Cette limite, héritée des écrans touts petits, est toujours en vigeur car il est plus facile de scanner un code sur une courte colonne qu’en faisant des aller-retours constant.

Si une ligne est trop longue, il existe plusieurs manières de la racourcir :

foo = la_chose_au_nom_si_long_quelle_ne_tient_pas_sur(
          une, 
          carte, 
          de, 
          munchkin)

Ici l’indentation entre le nom de la fonction et des paramètres est légèrement différente pour mettre en avant la distinction.

Une variante :

foo = la_chose_au_nom_si_long_quelle(ne, tient, pas, sur, carte 
                                     une, de, munchkin)

Si c’est un appel chainé, on peut utiliser \ pour mettre à la ligne :

queryset = ModelDjangoALaNoix.objects\
                             .filter(banzai=True)\
                             .exclude(chawarma=False)

Si c’est une structure de données, on peut se la jouer langage fonctionel de la vibes du flex :

chiffres = [
    1, 2, 3,
    4, 5, 6,
]
 
contacts = {
    'Cleo': (),
    'Ramses': (
        ('maman', '0248163264'),
        ('papa', '01234567890'),
        ('mamie', '55555555'),
        ('momie', '066642424269')
    )
}

Séparer les fonctions et les classes à la racine d’un module par 2 lignes vides. Les méthodes par 1 ligne vide. Parfois je triche et je fais 3 et 2 au lieu de 2 et 1.

Les imports de plusieurs modules doivent être sur plusieurs lignes :

import sys
import os

Et non :

import sys, os

Bien sûr, ce n’est pas valable pour from x import z.

Souvenez-vous qu’on peut utiliser les parenthèses pour diviser de longues lignes. Par exemple :

from minibelt import (dmerge, get, iget, normalize, 
                      chunks, window, skip_duplicates, flatten)

Idem pour les chaînes très longues :

s = ("Les chaînes Python sont automatiquement"
     "concaténées par la VM si elles sont "
     "uniquement séparées par des espaces "
     "ou sauts de lignes.")

Pour en revenir aux lignes d’import, on doit les ordonner ainsi :

Exemple :

import os  # import module de la lib standard
import sys # on groupe car même type 
 
from itertools import islice  # import du contenu du module
from collections on namedtuple # import groupe car même type
 
import requests # import lib tierce partie
import arrow # on groupe car même type
 
from django.conf import settings # tierce partie, contenu du module
from django.shortcuts import redirect # on groupe car même type
 
from mon_projet.mon_module import ma_bite # mon projet

Format du fichier

Indentation : 4 espaces. Pas de tab. C’est tout. Ce n’est pas du PEP8, c’est juste que les codes qui utilisent les tabs sont en (très très très très très très très très) grande minorité dans la communauté Python. Donc faites pas chier. Sinon on vous attend à la sortie de l’école. Tous.

Encoding : UTF8 ou ASCII (ce qui est de l’UTF8 de toute façon).

Docstrings

(c.f. PEP257)

On utilise toujours des triples quotes :

def fonction_avec_docstring_courte():
    """Résumé en une ligne."""
    pass

Si la docstring est longue (elle peut être très très très longue si vous le souhaitez) :

def fonction():
    """Résumé en une ligne suivi d'une line vide.
 
    Description longue de la fonction qui 
    se termine par une ligne vide puis une
    triple quotes sur sa propre ligne.
 
    """

Noms de variables

Lettres seules, en minuscule : pour les boucles et les indices.

Exemple :

for x in range(10):
    print(x)
 
i = get_index() + 12
print(ma_liste[i])

Lettres minuscules + underscores : pour les modules, variables, fonctions et méthodes.

une_variable = 10
 
def une_fonction():
    return locals() or {}
 
class UneClasse:
    def une_methode_comme_une_autre(self):
        return globals()

Lettres majuscules + underscores : pour les (pseudo) constantes.

MAX_SIZE = 100000  # à mettre après les imports

Camel case : nom de classe.

class CeciEstUneClasse:
    def methodiquement(self):
        pass

Si le nom contient un acronyme, on fait une entorse à la règle :

class HTMLParserCQFDDDTCCMB:
    def methodiquement(self):
        pass

On n’utilise PAS le mixedCase.

flattr this!

Afficher le queryset d’une requête dans les logs SQL sous Django

mercredi 25 décembre 2013 à 12:38

C’est Noël, 2 articles rien que pour vous dont un très interressant de Sam.

L’ORM de django pour les bases de données est chouette, agréable à utiliser mais construit des requêtes SQL qu’on ne peut reconnaître lors de l’analyse des logs MYSQL du premier coup d’oeil. Et quand on a des centaines de requêtes par secondes c’est carrément impossible de s’y retrouver.

Ce que je vous propose ici c’est d’afficher le queryset (sa ligne et le fichier qui le contient) qui a permit d’exêcuter la requête SQL que vous voyez défiler dans les logs SQL sous forme de commentaires SQL.

L’application se nomme Django Sql StackTrace. C’est facile à installer et ça peut sauver des heures de debug.

Installation Django Sql StackTrace:

Une bonne PIP comme toujours pour bien commencer.

pip install django-sql-stacktrace

Dans votre fichier settings de django.

INSTALLED_APPS = (
    .........................
    'sqlstacktrace',
    .........................
)
 
SQL_STACKTRACE = True

La variable SQL_STACKTRACE sert à activer le debug.
Pensez à le désactiver lorsque vous n’en avez pas besoin.

Où se trouve mes super infos de debug ?

D’après la doc vous pouvez executer un watch

watch -n1 mysqladmin -u login -pmot_de_passe processlist --verbose

Chez moi ça n’a rien donné. Mais du côté des logs MySQL la magie a opérée.
Vérifiez tout d’abord que vos logs sont activés dans mysql.

vi /etc/my.cnf
[mysqld]
......
log = /var/logs/mysql.log
......

Comment on teste ça ?

Redemarrez votre serveur web, surfez sur les pages de votre projet et observez les logs MySql. Vous deviez voir quelques chose de similaire:

tail -F /var/logs/mysql.log
		  644 Query	SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 65290
/* File "/Users/max/work/mon_projet/apps/mon_apps/views/others.py", line 146, in user_public_page
	user = User.objects.get(pk=user_id)
*/

Observez cette merveille !
Entre /* */ sont les infos générées par django-sql-stacktrace. J’ai nettoyé quelques fichiers pour plus de lisibilité.
Vous avez droit au chemin du fichier de la requête, à la ligne de la requête et à la requête django elle-même.

Une alternative ? J’ai pas envie d’installer d’app.

Pour les grosses feignasses ou si vous voulez juste tester occasionnellement quelques queries vous pouvez utiliser la méthode extra pour ajouter vos propres commentaires.

videos = Video.objects.filter(status='online').extra(where=['1=1 /* ceci apparaitra dans les logs mysql ! */'])

Cependant le WHERE 1=1 peut causer quelques baisses de performances, mais lorsqu’on est en debug en local ça peut servir !

PS: Je rappelle également le formidable outil django-debug-toolbar qui devient vite indispensable.

Alors ? Elle est pas belle la vie ?

flattr this!

Est-ce que “framework x” supporte la charge ?

mardi 24 décembre 2013 à 22:08

Oui.

flattr this!