Reprise du message précédent :

 
saturation ?

Non non. C'est sample 0 gauche + sample 0 droit + sample 1 gauche + sample 1 droit etc.

d'expérience fait gaffe à l'endianess entre le pcm et l'encodage dans le wav aussi  

Non.

mais bon d'un autre côté je me rappelle que quand on se trompe dans l'endianess le son c'est du n'importe quoi, pas juste un souffle

Ouais j'ai remarqué ça. Du coup dans le process je fais une conversion d'endianness. C'est pour ça que je me demandais s'il pouvait y avoir un shmurtz entre les short signed et unsigned.

J'sais plus, une fois j'ai essayé de lancer le mode debug mais ça galère un peu des fois, et là surtout j'ai genre ouvert un log de 40 Mo Ca a pas planté tout de suite, juste mis un message d'erreur de mémoire (bon point ), et c'est après quand j'ai voulu le supprimer qu'il a pas aimé
 
Mais ça va c'est pas pire qu'Eclipse en plantage, et mieux en IDE

tu 'vois' le souffle dans audacity and co ou pas ?

Ouais, le spectre est un poil plus épais.

comme avec un décalage  

Un décalage ?

tu as inversé l'endianess et tu es décalé d'un byte, ce qui fait que les bits de poids fort sont corrects mais pas les bits de poids faible, d'où le souffle

Bon maschknlinne, c'est fini de jouer les justiciers du net là ?

Tu veux dire que si on prend l'exemple du son stéréo comme ça (on s'occupe que de la droite) :
0000 b7ff 0000 f4ff 0000 2dff
Je devrais en fait avoir
0000 fff4 0000 ff2d 0000 ff... ???

Il y a Floola. C'est un exe de 20 Mo, point final.
/

example:
le flux gauche:
0000 0001 0002 0003 0004

le flux droit:
10fe 10ff 1100 1101 1102

mergé ça doit donner ça:
0000 10fe 0001 10ff 0002 1100 0003 1101 0004 1102

mais tu as inversé l'endianess par erreur:
0000 fe10 0100 ff10 0200 0011 0300 0111 0400 0211

là ca donne n'importe quoi
mais imagine que tu as aussi inséré un un octet en trop au debut: (tu es décalé donc)
0000 00fe 1001 00ff 1002 0000 1103 0001 1104 0002 11xx

tu te retrouves avec les bits de poids forts de gauche avec les bits de poids faible de droite et inversément.

Donc globalement ça sort un son à peut prés bon car les bits de poids fort sont les plus importants mais il y a un souffle car ceux de poids faibles sont incorrects.

je crois que j'ai fais bugger Riot...

et a l'utilisation ? C'est bien, pas bien ?

deep copy en java : clone / serializable / autre ?  
 
C'est pour faire un petit système transactionnel : on travail sur une copie d'une grappe d'objet. Le problème étant de faire la copie de la grappe...

c'est pas si grave  
et comme ça elle ne la chopera pas adulte

monsieur et madame Harko ont un fille qui vent de la drogue, comment s'appelle-t-elle ?  

au fait hier c'est ici qu'on parlait de formulaires d'upload ? Savez qu'avec safari/osx si on dragge un dossier sur un input-file, il le zippe et passe ce fichier a l'input?

ça c'est bien ( si le formulaire à l'autre bout est capable de le gérer quand meme )

Réponds plutôt à une question :
 
Vu sur le blog de N.Batchelder, pourquoi dans son premier exemple _db n'est pas recréé à chaque instance?

 
Pour la même raison que __init__ et get ne sont pas créés à chaque instance, les variables locales dans le scope d'un bloc "class" deviennent les variables membres de la classe, que ce soit des fonctions ou d'autres types d'objets. Les membres de classe ne sont pas instanciés pour chaque instance de la classe, contrairement aux membres de la classe.

Je viens de retomber sur ceci.  Ca devrait en amuser certains: http://www.cs.washington.edu/homes [...] nload.html

comme 0x90 dit

En fait, la création d'une classe en Python est extrèmement simple, même si un peu bizarre par rapport à celle de Ruby: Python commence par exécuter tout le code contenu dans le corps de la classe, récupère tout ce qui a été créé (~locals()) et file tout ça comme dct à la métaclasse (le 3e argument à type.__new__).
 
En gros,

class Foo(object):
    def method(self):
        print "I am a method of", self
    @classmethod
    def class_method(cls):
        print "I am a class method of", cls

est équivalent à

def make_foo():
    def method(self):
        print "I am a method of", self
    @classmethod
    def class_method(cls):
        print "I am a class method of", cls
    return locals()
 
Foo = type("Foo", (object,), make_foo())

(tu peux tester dans un script ou un REPL)
 
Il y a une ou deux étapes supplémentaires pour gérer les métaclasses (quand ce n'est pas type), mais c'est tout (enfin la gestion des scopes est aussi spécifique il me semble). Et ça explique entre autres pourquoi il n'est pas possible de référer à la classe dans son propre body:

class Foo(object):
    bar = 4
class Spam(Foo):
    eggs = Spam.bar + 1

va pêter parce que Spam n'existe pas encore à la création de eggs (alors qu'en Ruby, Spam existe à partir du moment où on est dans sa scope, et en bonus tu as self qui pointe sur la classe-instance).

class Foo(object):
    def method(self):
        print "I am a method of", self
    @classmethod
    def class_method(cls):
        print "I am a class method of", cls

def make_foo():
    def method(self):
        print "I am a method of", self
    @classmethod
    def class_method(cls):
        print "I am a class method of", cls
    return locals()
 
Foo = type("Foo", (object,), make_foo())

class Foo(object):
    bar = 4
class Spam(Foo):
    eggs = Spam.bar + 1

 
En parlant de ça, je recommande la lecture de "metaprogramming ruby"

Pour l'instant je vais lire Ruby Best Practices, qui a l'avantage d'être gratuit

Je vois à fait comment ça fonctionne, j'ai pas mal testé hier soir et je me suis aperçu que la classe en elle même était une instance de classobj, je le savais mais je n'avais pas réalisé. Par contre d'après mes tests, les variables de type string - et surement d'autres - définies dans le bloc "class" sont redéfinies à chaque nouvelle instance. Ou alors, j'ai raté un truc.

http://www.eatahotbowlofdicks.com/
 

T'as raté un truc.

Quand tu dis que c'est redéfini à chaque instance, tu parles d'un truc comme ça:

#
    >>> class Foo(object):
    ...    a = "gnu"
    ...
    >>> spam = Foo()
    >>> spam.a
    'gnu'
    >>> spam.a = "ugn"
    >>> spam.a
    'ugn'
    >>> egg = Foo()
    >>> egg.a
    'gnu'

?

back from Germany, avec mon petit vélo et ma petite cariole

P'tain, Surcouf, depuis que ça a été racheté par Mulliez, ça ressemble plus à rien.
Le magasin Daumesnil est maintenant un mélange de Fnac et de rayon électroménager d'un hyper Auchan.

On va dire que c'est utilisable.  
Moi ça me suffisait quand j'avais mon iPod. Comme Elmo, je refuse de foutre iTunes sur mon Pécé, ça n'est pas une option. Donc de toute façon, il n'y a pas d'autre alternative que Floola.

>>> class Foo:
...     x = []
...     def __init__(self):
...             self.x.append(self)
... 
>> Foo()
<__main__.Foo instance at 0xb7696b2c>
>> Foo()
<__main__.Foo instance at 0xb7696b0c>
>>> len(Foo.x) > 0
True
 
>>> class Bar:
...     x = ""
...     def __init__(self):
...             self.x += "-"
... 
>>> Bar()
<__main__.Bar instance at 0xb7696b6c>
>>> Bar()
<__main__.Bar instance at 0xa4c140c>
>>> len(Bar.x) > 0
False

ShinuzaG

str étant immutable en Python, self.x += "-" ~ self.x = self.x + "-" ~ setattr(self, "x", getattr(self, "x" ) + "-" ) ~ (dans ce cas précis) self.x = type(self).x + "-"

Au lieu de modifier Bar.x, tu crées un self.x qui shadow Bar.x, ça veut pas dire que Bar.x n'existe plus (ou qu'il se reset à chaque nouvelle instance), juste que tu le vois plus

T'en sais juste assez pour être dangereux, j'en étais sûr