import random
from rtcmix import *
from chimes_source import * # Chime.play()
from rhythmblock import * # rhythmBlock.rhythmTwist() and
rhythmBlock.printStuff()
from pitchblock import * # pitchBlock.pitchTwist() and
pitchBlock.printStuff()
from lenEval import * #greaterThan.sovler()
indexrand = random.Random()
indexrand.seed(2)
chime = Chime()
notes = pitchBlock()
rhythm = rhythmBlock()
solve = greaterThan()
class arrayBlock:
def __init__(self, theTempo, start):
self.__A = []
self.__B = []
self.__start = start
self.__tempo = theTempo
def player(self, length, tempo, octave, pan, seed):
tempo = (120, self.__tempo)
for a in range(length):
one = indexrand.randint(0, 3)
two = indexrand.randint(0, 7)
self.__A = self.__A + notes.pitchTwist(one , two)
for b in range(length):
one = indexrand.randint(0, 3)
two = indexrand.randint(0, 7)
self.__B = self.__B + rhythm.rhythmTwist(one , two)
lenA = len(self.__A)
lenB = len(self.__B)
var = solve.solver(lenA, lenB)
for c in range(var):
print self.__A[c]
self.__start = self.__start + tb(self.__B[var])
chime.play(self.__start, self.__A[var], octave, pan,
seed)
This almost does exactly what I want, and is far cleaner than my
previous attempts.
The only problem is that now all my arguments are being passed as zeros!
I assume this has to do with WHEN I'm referencing self.__A and self.__B?
AS
On Dec 23, 2008, at 10:20 AM, Steve Holden wrote:
D'Arcy J.M. Cain wrote:
On Mon, 22 Dec 2008 22:32:17 -0500
Aaron Stepp <stepp.aa...@gmail.com> wrote:
Instead of writing a long list of initializations like so:
A = [ ]
B = [ ]
...
Y = [ ]
Z = [ ]
I'd like to save space by more elegantly turning this into a
loop. If
Well, if all you want is a loop:
for v in vars:
locals()[v] = []
Note that this isn't guaranteed to work. While locals() will return a
dict containing the names and values from the local namespace, you
won't
affect the local namespace by assigning values to the appropriate
keys:
def f():
... a = "hello"
... locals()["a"] = "goodbye"
... print a
...
f()
hello
If you look at the function's code you will see that the local "a" is
accessed using the LOAD_FAST and STORE_FAST opcodes, which take
advantage of the knowledge that the name is local - the interpreter
analyzed the function body looking for assignments to non-globals, and
optimizes its treatment of such names.
dis.dis(f)
2 0 LOAD_CONST 1 ('hello')
3 STORE_FAST 0 (a)
3 6 LOAD_CONST 2 ('goodbye')
9 LOAD_GLOBAL 0 (locals)
12 CALL_FUNCTION 0
15 LOAD_CONST 3 ('a')
18 STORE_SUBSCR
4 19 LOAD_FAST 0 (a)
22 PRINT_ITEM
23 PRINT_NEWLINE
24 LOAD_CONST 0 (None)
27 RETURN_VALUE
It's hard to tell if that's what you actually need though without
deeper analysis of your requirements.
I think it's unlikely that the OP really does need to create names
dynamically, and should look at using either a dict indexed by the
letters of self.__abet, or a list indexed from 0 to 24 instead. But
you
*are* correct about the need for a little more information ;-)
regards
Steve
--
Steve Holden +1 571 484 6266 +1 800 494 3119
Holden Web LLC http://www.holdenweb.com/
--
http://mail.python.org/mailman/listinfo/python-list
--
http://mail.python.org/mailman/listinfo/python-list
