iterating initalizations

Discussion in 'Python' started by Aaron Stepp, Dec 22, 2008.

  1. Aaron Stepp

    Aaron Stepp Guest

    Hi all:

    I'm new to python and trying to save time and code by iterating
    through list initializations as well as the assignments. I have the
    following code:

    import random
    from rtcmix import *
    from chimes_source import *
    from rhythmblock import *
    from pitchblock import *

    indexrand = random.Random()
    indexrand.seed(2)

    rhythm = rhythmBlock()
    pitch = pitchBlock()

    class pitchAndRhythm:

    def __init__self:

    self.__abet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'


    def listCreate(self, num):

    if num > 25:

    print "Oops. This won't work"

    else:

    for a in range(num):

    b = indexrand.randint(0, 3)

    c = indexrand.randint(0, 7)

    index = self.__abet[a]

    index = [ ]

    index = index.append(rhythm.rhythmTwist(b, c))


    This doesn't do what I expect (probably because I don't have a clue
    what I'm doing!): initalizing, then filling new arrays, each new one
    called A[ ], then B[ ], etc.

    This seems very un-pythonic, and I'm sure there is a right way to do
    it. I'm just lost!

    Thanks

    Aaron Stepp
     
    Aaron Stepp, Dec 22, 2008
    #1
    1. Advertising

  2. Aaron Stepp

    r Guest

    I can't check you code because i don't have these modules but here is
    the code with proper indention


    import random
    from rtcmix import *
    from chimes_source import *
    from rhythmblock import *
    from pitchblock import *
    indexrand = random.Random()
    indexrand.seed(2)
    rhythm = rhythmBlock()
    pitch = pitchBlock()

    class pitchAndRhythm:
    def __init__self:
    self.__abet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

    def listCreate(self, num):
    if num > 25:
    print "Oops. This won't work"
    else:
    for a in range(num):
    b = indexrand.randint(0, 3)
    c = indexrand.randint(0, 7)
    index = self.__abet[a]
    index = [ ]
    index = index.append(rhythm.rhythmTwist(b, c))
     
    r, Dec 23, 2008
    #2
    1. Advertising

  3. Aaron Stepp

    r Guest

    I can't check you code because i don't have these modules but here is
    the code with proper indention

    import random
    from rtcmix import *
    from chimes_source import *
    from rhythmblock import *
    from pitchblock import *
    indexrand = random.Random()
    indexrand.seed(2)
    rhythm = rhythmBlock()
    pitch = pitchBlock()

    class pitchAndRhythm:
    def __init__(self):
    self.__abet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    def listCreate(self, num):
    if num > 25:
    print "Oops. This won't work"
    else:
    for a in range(num):
    b = indexrand.randint(0, 3)
    c = indexrand.randint(0, 7)
    index = self.__abet[a]
    index = [ ]
    index = index.append(rhythm.rhythmTwist(b, c))

    take 2: notice the "(" and ")" around the arg to __init__
     
    r, Dec 23, 2008
    #3
  4. Aaron Stepp

    Aaron Stepp Guest

    On Dec 22, 2008, at 10:15 PM, r wrote:

    > I can't check you code because i don't have these modules but here is
    > the code with proper indention
    >
    > import random
    > from rtcmix import *
    > from chimes_source import *
    > from rhythmblock import *
    > from pitchblock import *
    > indexrand = random.Random()
    > indexrand.seed(2)
    > rhythm = rhythmBlock()
    > pitch = pitchBlock()
    >
    > class pitchAndRhythm:
    > def __init__(self):
    > self.__abet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    > def listCreate(self, num):
    > if num > 25:
    > print "Oops. This won't work"
    > else:
    > for a in range(num):
    > b = indexrand.randint(0, 3)
    > c = indexrand.randint(0, 7)
    > index = self.__abet[a]
    > index = [ ]
    > index = index.append(rhythm.rhythmTwist(b, c))
    >
    > take 2: notice the "(" and ")" around the arg to __init__



    Thanks for the help so far, I think I'm starting to get a hang of the
    syntax.

    I think I need to state my goal more clearly.

    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
    I need to just write it out, I guess that's ok... but it would be much
    cleaner. I'm a composer, not a programmer, so some of this is quite
    above me.

    I usually ask as a last resort, but I've been through the tutorial and
    didn't find this. I've got a couple python books, but I'd like to
    finish this piece sooner than later.

    Thanks!

    AS
     
    Aaron Stepp, Dec 23, 2008
    #4
  5. Aaron Stepp

    r Guest

    >>> class test():
    def __init__(self, name):
    self.name = 'My name is %d' %name


    >>> l = []
    >>> for name in range(10):

    l.append(test(name))


    >>> l

    [<__main__.test instance at 0x02852E18>, <__main__.test instance at
    0x02852C38>, <__main__.test instance at 0x028528A0>, <__main__.test
    instance at 0x02852E90>, <__main__.test instance at 0x02852EE0>,
    <__main__.test instance at 0x02852F30>, <__main__.test instance at
    0x02852F80>, <__main__.test instance at 0x02852FD0>, <__main__.test
    instance at 0x023AFC60>, <__main__.test instance at 0x02855030>]
    >>> l[0].name

    'My name is 0'
    >>> l[1].name

    'My name is 1'
     
    r, Dec 23, 2008
    #5
  6. Aaron Stepp

    Chris Rebert Guest

    On Mon, Dec 22, 2008 at 7:32 PM, Aaron Stepp <> wrote:
    <snip>
    >
    > Thanks for the help so far, I think I'm starting to get a hang of the
    > syntax.
    >
    > I think I need to state my goal more clearly.
    >
    > 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 I
    > need to just write it out, I guess that's ok... but it would be much
    > cleaner. I'm a composer, not a programmer, so some of this is quite above
    > me.
    >


    So, are these variables supposed to be module-level, or attributes of
    class pitchAndRhythm, or what?
    Also, are you going to use the variables normally or are you going to
    need "variable variables" (e.g. like $$var in PHP, which gives the
    value of the variable with the name of the string stored in $var)?

    Cheers,
    Chris

    --
    Follow the path of the Iguana...
    http://rebertia.com
     
    Chris Rebert, Dec 23, 2008
    #6
  7. Aaron Stepp

    Aaron Stepp Guest

    On Dec 22, 2008, at 10:43 PM, Chris Rebert wrote:

    > On Mon, Dec 22, 2008 at 7:32 PM, Aaron Stepp <>
    > wrote:
    > <snip>
    >>
    >> Thanks for the help so far, I think I'm starting to get a hang of the
    >> syntax.
    >>
    >> I think I need to state my goal more clearly.
    >>
    >> 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 I
    >> need to just write it out, I guess that's ok... but it would be much
    >> cleaner. I'm a composer, not a programmer, so some of this is
    >> quite above
    >> me.
    >>

    >
    > So, are these variables supposed to be module-level, or attributes of
    > class pitchAndRhythm, or what?
    > Also, are you going to use the variables normally or are you going to
    > need "variable variables" (e.g. like $$var in PHP, which gives the
    > value of the variable with the name of the string stored in $var)?
    >
    > Cheers,
    > Chris
    >
    > --
    > Follow the path of the Iguana...
    > http://rebertia.com



    The're going to only be part of the pitchAndRhythm class. Simply put,
    I just need enough arrays to hold a list of pitches/rhythms. Then
    I'll have each list member returned to an instrument defined in
    another module.

    As I'm hacking away at the code, I'm realizing that maybe I can do
    this with just and A = [] and B = []. But I'm not sure...

    Thanks again.

    AS
     
    Aaron Stepp, Dec 23, 2008
    #7
  8. Aaron Stepp

    Rhodri James Guest

    On Tue, 23 Dec 2008 03:52:35 -0000, Aaron Stepp <>
    wrote:

    > Simply put, I just need enough arrays to hold a list of
    > pitches/rhythms. Then I'll have each list member returned to an
    > instrument defined in another module.


    One "array" can hold a list of pitches/rhythms. I'm still not terribly
    clear as to why you need so many. Is each list intended for a different
    instrument, so you're more looking at:

    violin_1 = [ ...stuff... ]
    violin_2 = [ ...other stuff...]
    viola = [ ...really sweet stuff... ]
    cello = [ ...really boring stuff... ]

    --
    Rhodri James *-* Wildebeeste Herder to the Masses
     
    Rhodri James, Dec 23, 2008
    #8
  9. Aaron Stepp

    Chris Rebert Guest

    On Mon, Dec 22, 2008 at 7:52 PM, Aaron Stepp <> wrote:
    >
    > On Dec 22, 2008, at 10:43 PM, Chris Rebert wrote:
    >
    >> On Mon, Dec 22, 2008 at 7:32 PM, Aaron Stepp <>
    >> wrote:
    >> <snip>
    >>>
    >>> Thanks for the help so far, I think I'm starting to get a hang of the
    >>> syntax.
    >>>
    >>> I think I need to state my goal more clearly.
    >>>
    >>> 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 I
    >>> need to just write it out, I guess that's ok... but it would be much
    >>> cleaner. I'm a composer, not a programmer, so some of this is quite
    >>> above
    >>> me.
    >>>

    >>
    >> So, are these variables supposed to be module-level, or attributes of
    >> class pitchAndRhythm, or what?
    >> Also, are you going to use the variables normally or are you going to
    >> need "variable variables" (e.g. like $$var in PHP, which gives the
    >> value of the variable with the name of the string stored in $var)?
    >>
    >> Cheers,
    >> Chris
    >>
    >> --
    >> Follow the path of the Iguana...
    >> http://rebertia.com

    >
    >
    > The're going to only be part of the pitchAndRhythm class. Simply put, I
    > just need enough arrays to hold a list of pitches/rhythms. Then I'll have
    > each list member returned to an instrument defined in another module.
    >
    > As I'm hacking away at the code, I'm realizing that maybe I can do this with
    > just and A = [] and B = []. But I'm not sure...
    >


    Do you really need to name them, or are the names arbitrary and you
    only really care about having N distinct lists?

    Cheers,
    Chris

    --
    Follow the path of the Iguana...
    http://rebertia.com
     
    Chris Rebert, Dec 23, 2008
    #9
  10. On Mon, 22 Dec 2008 22:32:17 -0500
    Aaron Stepp <> 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] = []

    It's hard to tell if that's what you actually need though without
    deeper analysis of your requirements.

    --
    D'Arcy J.M. Cain <> | Democracy is three wolves
    http://www.druid.net/darcy/ | and a sheep voting on
    +1 416 425 1212 (DoD#0082) (eNTP) | what's for dinner.
     
    D'Arcy J.M. Cain, Dec 23, 2008
    #10
  11. Aaron Stepp

    Steve Holden Guest

    D'Arcy J.M. Cain wrote:
    > On Mon, 22 Dec 2008 22:32:17 -0500
    > Aaron Stepp <> 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/
     
    Steve Holden, Dec 23, 2008
    #11
  12. Aaron Stepp

    Aaron Stepp Guest

    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 <> 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
    >
     
    Aaron Stepp, Dec 23, 2008
    #12
  13. On Tue, 23 Dec 2008 10:20:59 -0500
    Steve Holden <> wrote:
    > D'Arcy J.M. Cain wrote:
    > > 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


    This was my test:

    >>> locals()['x'] = "hello"
    >>> x

    'hello'
    >>> locals()['x'] = "goodbye"
    >>> x

    'goodbye'

    Just didn't want people to think that I post without testing.

    In any case, even if that worked as expected I am pretty sure that it
    is the wrong solution but without knowing more about what the OP is
    doing it is impossible to know what the right answer is.

    --
    D'Arcy J.M. Cain <> | Democracy is three wolves
    http://www.druid.net/darcy/ | and a sheep voting on
    +1 416 425 1212 (DoD#0082) (eNTP) | what's for dinner.
     
    D'Arcy J.M. Cain, Dec 23, 2008
    #13
  14. Aaron Stepp

    Steve Holden Guest

    D'Arcy J.M. Cain wrote:
    > On Tue, 23 Dec 2008 10:20:59 -0500
    > Steve Holden <> wrote:
    >> D'Arcy J.M. Cain wrote:
    >>> 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

    >
    > This was my test:
    >
    >>>> locals()['x'] = "hello"
    >>>> x

    > 'hello'
    >>>> locals()['x'] = "goodbye"
    >>>> x

    > 'goodbye'
    >
    > Just didn't want people to think that I post without testing.
    >
    > In any case, even if that worked as expected I am pretty sure that it
    > is the wrong solution but without knowing more about what the OP is
    > doing it is impossible to know what the right answer is.
    >

    The thing you overlooked was that the locals of a function are special.
    The locals of a module are the globals!

    >>> def lisg():

    .... return locals() is globals()
    ....
    >>> locals() is globals()

    True
    >>> lisg()

    False
    >>>


    regards
    Steve
    --
    Steve Holden +1 571 484 6266 +1 800 494 3119
    Holden Web LLC http://www.holdenweb.com/
     
    Steve Holden, Dec 23, 2008
    #14
  15. Aaron Stepp

    Rhodri James Guest

    On Tue, 23 Dec 2008 15:39:52 -0000, Aaron Stepp <>
    wrote:

    > 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!


    Which "all" your arguments? There are an awful lot there; what *exactly*
    do
    you mean?

    > I assume this has to do with WHEN I'm referencing self.__A and self.__B?


    If you mean __A and __B are full of zeroes, then you should suspect your
    notes.pitchTwist() and rhythm.rhythmTwist() methods of returning zeroes.

    --
    Rhodri James *-* Wildebeeste Herder to the Masses
     
    Rhodri James, Dec 23, 2008
    #15
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Mothra
    Replies:
    1
    Views:
    547
    ! aaa
    May 27, 2004
  2. Ron
    Replies:
    0
    Views:
    466
  3. Jeremy

    Iterating through controls (VB)

    Jeremy, Jul 31, 2003, in forum: ASP .Net
    Replies:
    1
    Views:
    1,490
    Marina
    Jul 31, 2003
  4. Jacko
    Replies:
    8
    Views:
    629
  5. carl
    Replies:
    5
    Views:
    2,513
    James Kanze
    Nov 25, 2009
Loading...

Share This Page