A scoping question

Discussion in 'Python' started by It's me, Dec 28, 2004.

  1. It's me

    It's me Guest

    This must be another newbie gotchas.

    Consider the following silly code, let say I have the following in file1.py:

    #=============
    import file2
    global myBaseClass
    myBaseClass = file2.BaseClass()
    myBaseClass.AddChild(file2.NextClass())
    #=============

    and in file2.py, I have:

    #=============
    global myBaseClass
    class BaseClass:
    def __init__(self):
    self.MyChilds = []
    ...
    def AddChild(NewChild):
    self.MyChilds.append(NewChild)
    ...
    class NextClass:
    def __init__(self):
    for eachChild in myBaseClass.MyChilds: # <- ERROR
    ...
    #=============

    When I run this, Python complains that myBaseClass is undefined in the last
    line above.

    What am I doing wrong? (Yes, I know I am thinking too much in C). I
    thought the global declaration would have been sufficient but it's obviously
    not.

    Thanks,
    It's me, Dec 28, 2004
    #1
    1. Advertising

  2. On Tue, 28 Dec 2004 19:34:36 GMT, It's me <> wrote:
    > This must be another newbie gotchas.
    >
    > Consider the following silly code, let say I have the following in file1.py:
    >
    > #=============
    > import file2
    > global myBaseClass
    > myBaseClass = file2.BaseClass()
    > myBaseClass.AddChild(file2.NextClass())
    > #=============


    You have declared myBaseClass to be global, but it doesn't exist.

    Consider the following code:

    global name
    print name.__len__()

    This will return a NamError

    However, the following code will run just fine:

    global name
    name = "python"
    print name.__len__()

    will return 6

    >
    > and in file2.py, I have:
    >
    > #=============
    > global myBaseClass
    > class BaseClass:
    > def __init__(self):
    > self.MyChilds = []
    > ...
    > def AddChild(NewChild):
    > self.MyChilds.append(NewChild)
    > ...
    > class NextClass:
    > def __init__(self):
    > for eachChild in myBaseClass.MyChilds: # <- ERROR
    > ...
    > #=============
    >
    > When I run this, Python complains that myBaseClass is undefined in the last
    > line above.
    >
    > What am I doing wrong? (Yes, I know I am thinking too much in C). I
    > thought the global declaration would have been sufficient but it's obviously
    > not.
    >
    > Thanks,
    >
    > --
    > http://mail.python.org/mailman/listinfo/python-list
    >


    HTH

    --
    Premshree Pillai
    http://www.livejournal.com/~premshree
    Premshree Pillai, Dec 28, 2004
    #2
    1. Advertising

  3. It's me

    It's me Guest

    "Premshree Pillai" <> wrote in message
    news:...
    > On Tue, 28 Dec 2004 19:34:36 GMT, It's me <> wrote:
    > > This must be another newbie gotchas.
    > >
    > > Consider the following silly code, let say I have the following in

    file1.py:
    > >
    > > #=============
    > > import file2
    > > global myBaseClass
    > > myBaseClass = file2.BaseClass()
    > > myBaseClass.AddChild(file2.NextClass())
    > > #=============

    >
    > You have declared myBaseClass to be global, but it doesn't exist.
    >


    No, myBaseClass exists in file1.py. The question is how can I tell
    file2.py that the global variable is in file1 (without doing a silly
    file1.myBaseClass....

    Since I am invoking file2 from file1, I would have thought that global
    variables in file1 exists automatically....(too much C thinking, I know)
    It's me, Dec 28, 2004
    #3
  4. On Tue, 28 Dec 2004 19:59:01 GMT, It's me <> wrote:
    >
    > "Premshree Pillai" <> wrote in message
    > news:...
    > > On Tue, 28 Dec 2004 19:34:36 GMT, It's me <> wrote:
    > > > This must be another newbie gotchas.
    > > >
    > > > Consider the following silly code, let say I have the following in

    > file1.py:
    > > >
    > > > #=============
    > > > import file2
    > > > global myBaseClass
    > > > myBaseClass = file2.BaseClass()
    > > > myBaseClass.AddChild(file2.NextClass())
    > > > #=============

    > >
    > > You have declared myBaseClass to be global, but it doesn't exist.
    > >

    >
    > No, myBaseClass exists in file1.py. The question is how can I tell


    Umm, from the sample code (for file2.py) that you provided, I don't
    see myBaseClass. You've only declared it to be global in file2.py, but
    it does not exist -- does not exist in the sense that it has no type
    associated with it, which in turn means meaning you cannot apply
    methods to it.

    > file2.py that the global variable is in file1 (without doing a silly
    > file1.myBaseClass....
    >
    > Since I am invoking file2 from file1, I would have thought that global
    > variables in file1 exists automatically....(too much C thinking, I know)
    >
    >
    > --
    > http://mail.python.org/mailman/listinfo/python-list
    >



    --
    Premshree Pillai
    http://www.livejournal.com/~premshree
    Premshree Pillai, Dec 28, 2004
    #4
  5. It's me wrote:
    > This must be another newbie gotchas.
    >
    > Consider the following silly code, let say I have the following in file1.py:
    >
    > #=============
    > import file2
    > global myBaseClass
    > myBaseClass = file2.BaseClass()
    > myBaseClass.AddChild(file2.NextClass())
    > #=============
    >
    > and in file2.py, I have:
    >
    > #=============
    > global myBaseClass
    > class BaseClass:
    > def __init__(self):
    > self.MyChilds = []
    > ...
    > def AddChild(NewChild):
    > self.MyChilds.append(NewChild)
    > ...
    > class NextClass:
    > def __init__(self):
    > for eachChild in myBaseClass.MyChilds: # <- ERROR
    > ...
    > #=============
    >
    > When I run this, Python complains that myBaseClass is undefined in the last
    > line above.
    >
    > What am I doing wrong? (Yes, I know I am thinking too much in C). I
    > thought the global declaration would have been sufficient but it's obviously
    > not.


    I think you're confused about what the global keword does. Declaring a
    name as global makes that name global *to the module*:

    http://docs.python.org/ref/global.html
    http://docs.python.org/lib/built-in-funcs.html#l2h-32

    What you probably want instead is:

    -------------------- file1.py --------------------
    import file2
    myBaseClass = file2.BaseClass()
    myBaseClass.AddChild(file2.NextClass())
    --------------------------------------------------

    -------------------- file2.py --------------------
    class BaseClass:
    def __init__(self):
    self.MyChilds = []
    def AddChild(self, NewChild):
    self.MyChilds.append(NewChild)
    class NextClass:
    def __init__(self):
    from file1 import myBaseClass # IMPORT
    for eachChild in myBaseClass.MyChilds:
    pass
    --------------------------------------------------

    Note that I import myBaseClass in __init__. If I imported it at the top
    of the module, then file1 would import file2 which would then import
    file1 and you'd have a circular dependency.

    As it is, your code is very tightly coupled. Why don't you put all this
    code into a single module?

    Steve
    Steven Bethard, Dec 28, 2004
    #5
  6. It's me wrote:
    > This must be another newbie gotchas.
    >
    > Consider the following silly code

    [snip tightly coupled code]

    A few options that also might work better than such tightly coupled modules:

    -------------------- file1.py --------------------
    import file2
    myBaseClass = file2.BaseClass()
    class NextClass:
    def __init__(self):
    for eachChild in myBaseClass.MyChilds:
    pass
    myBaseClass.AddChild(file2.NextClass())
    --------------------------------------------------

    -------------------- file2.py --------------------
    class BaseClass:
    def __init__(self):
    self.MyChilds = []
    def AddChild(self, NewChild):
    self.MyChilds.append(NewChild)
    --------------------------------------------------


    or


    -------------------- file1.py --------------------
    import file2
    myBaseClass = file2.BaseClass()
    myBaseClass.AddChild(file2.NextClass(myBaseClass))
    --------------------------------------------------

    -------------------- file2.py --------------------
    class BaseClass:
    def __init__(self):
    self.MyChilds = []
    def AddChild(self, NewChild):
    self.MyChilds.append(NewChild)
    class NextClass:
    def __init__(self, myBaseClass):
    for eachChild in myBaseClass.MyChilds:
    pass
    --------------------------------------------------
    Steven Bethard, Dec 28, 2004
    #6
  7. It's me

    It's me Guest

    Thanks, Steve.

    So, global is only to within a module (I was afraid of that). Those words
    flashed by me when I was reading it but since the word "module" didn't
    translate to "file" in my C mind, I didn't catch that.

    In that case, you are correct that I have to do an import of file1 in file2.

    Not that this is not real code, I am still trying to learn the ins and outs
    of Python by writing some silly code - but will be important to help me
    understand how I would write the real code.

    Regarding the question of not placing everything in one module, I wouldn't
    think that that's how I would do it. I might get ambitous later and write
    code for a larger project. In that case, I will need to know more about
    scoping across multiple modules. So, this helps me understand what to do.

    Thanks again.

    "Steven Bethard" <> wrote in message
    news:I5jAd.246742$5K2.73425@attbi_s03...

    <snip>

    >
    > I think you're confused about what the global keword does. Declaring a
    > name as global makes that name global *to the module*:
    >
    > http://docs.python.org/ref/global.html
    > http://docs.python.org/lib/built-in-funcs.html#l2h-32
    >
    > What you probably want instead is:
    >
    > -------------------- file1.py --------------------
    > import file2
    > myBaseClass = file2.BaseClass()
    > myBaseClass.AddChild(file2.NextClass())
    > --------------------------------------------------
    >
    > -------------------- file2.py --------------------
    > class BaseClass:
    > def __init__(self):
    > self.MyChilds = []
    > def AddChild(self, NewChild):
    > self.MyChilds.append(NewChild)
    > class NextClass:
    > def __init__(self):
    > from file1 import myBaseClass # IMPORT
    > for eachChild in myBaseClass.MyChilds:
    > pass
    > --------------------------------------------------
    >
    > Note that I import myBaseClass in __init__. If I imported it at the top
    > of the module, then file1 would import file2 which would then import
    > file1 and you'd have a circular dependency.
    >
    > As it is, your code is very tightly coupled. Why don't you put all this
    > code into a single module?
    >
    > Steve
    It's me, Dec 28, 2004
    #7
  8. naming conventions (WAS: A scoping question)

    It's me wrote:
    > #=============
    > import file2
    > global myBaseClass
    > myBaseClass = file2.BaseClass()
    > myBaseClass.AddChild(file2.NextClass())
    > #=============

    [snip]
    > #=============
    > global myBaseClass
    > class BaseClass:
    > def __init__(self):
    > self.MyChilds = []
    > ...
    > def AddChild(NewChild):
    > self.MyChilds.append(NewChild)
    > ...
    > class NextClass:
    > def __init__(self):
    > for eachChild in myBaseClass.MyChilds: # <- ERROR
    > ...
    > #=============


    Also worth mentioning if you're just starting with Python. Python has
    some official naming conventions:

    http://www.python.org/peps/pep-0008.html

    These are just recommendations of course, but if you have the option
    (e.g. you're not constrained by style enforced by your employer), and
    you'd like your code to look more like standard Python modules, you
    might consider using these suggestions. This would make your code look
    something like:

    #=============
    import file2
    global my_base_class
    my_base_class = file2.BaseClass()
    my_base_class.add_child(file2.NextClass())
    #=============

    #=============
    global my_base_class
    class BaseClass:
    def __init__(self):
    self.my_childs = []
    ...
    def add_child(new_child):
    self.my_childs.append(new_child)
    ...
    class NextClass:
    def __init__(self):
    for each_child in my_base_class.my_childs: # <- ERROR
    ...
    #=============

    Steve
    Steven Bethard, Dec 28, 2004
    #8
  9. On Tue, 28 Dec 2004 19:34:36 GMT, "It's me" <> declaimed
    the following in comp.lang.python:

    > This must be another newbie gotchas.
    >
    > Consider the following silly code, let say I have the following in file1.py:
    >
    > #=============
    > import file2
    > global myBaseClass


    #1 "global" only applies within a function definition,
    where it signals that the subsequent name will be modified within the
    function AND exists in the scope external to the function... If the
    object name ONLY appears on the right side of an assignment (within the
    function), "global" is not needed, as the scope rules will look-up the
    external item. However, if the object name appears on the left hand
    side, and there is NO "global", Python creates a local object (and will
    then complain if you used the name on a right-side before the assignment
    creating it).

    aGlobalItem = [1, 2, 3]

    def aFunction():
    global aGlobalItem
    aGlobalItem = ('a', 'b', 'c')
    return None

    Without the "global", the function would create a function-local
    called aGlobalItem, and never see the outside object.

    > myBaseClass = file2.BaseClass()
    > myBaseClass.AddChild(file2.NextClass())
    > #=============
    >
    > and in file2.py, I have:
    >
    > #=============
    > global myBaseClass
    > class BaseClass:
    > def __init__(self):
    > self.MyChilds = []
    > ...
    > def AddChild(NewChild):
    > self.MyChilds.append(NewChild)
    > ...
    > class NextClass:
    > def __init__(self):
    > for eachChild in myBaseClass.MyChilds: # <- ERROR
    > ...
    > #=============
    >
    > When I run this, Python complains that myBaseClass is undefined in the last
    > line above.
    >

    Which is correct. "global" only works within function
    definitions /within/ a module (file). To access stuff in other modules
    you must "import" the module.

    > What am I doing wrong? (Yes, I know I am thinking too much in C). I
    > thought the global declaration would have been sufficient but it's obviously
    > not.
    >

    #2 You are trying to create a set of recursive
    dependencies. File1 is getting an object definition from File2, but
    File2 needs the object created in File1...

    Terrible design, IMHO...


    And why is NextClass a "class"? Does it return a "NextClass"
    object?

    Either way... I'd probably change the __init__ to take two
    arguments: self (which is the NextClass object being created) and 'o'
    (the other argument), then use it as

    nc = NextClass(myBaseClass)

    --
    > ============================================================== <
    > | Wulfraed Dennis Lee Bieber KD6MOG <
    > | Bestiaria Support Staff <
    > ============================================================== <
    > Home Page: <http://www.dm.net/~wulfraed/> <
    > Overflow Page: <http://wlfraed.home.netcom.com/> <
    Dennis Lee Bieber, Dec 28, 2004
    #9
    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. Matt S.
    Replies:
    0
    Views:
    392
    Matt S.
    May 4, 2004
  2. Alan Little

    Beginner's scoping question

    Alan Little, Nov 10, 2004, in forum: Python
    Replies:
    6
    Views:
    263
    Alan Little
    Nov 12, 2004
  3. 2b|!2b==?

    scoping question

    2b|!2b==?, Apr 21, 2007, in forum: C++
    Replies:
    1
    Views:
    283
    Ivan Vecerina
    Apr 21, 2007
  4. Matt Barnicle
    Replies:
    10
    Views:
    629
    Bruno Desthuilliers
    Dec 2, 2007
  5. Cornelius Keller

    variable & scoping question.

    Cornelius Keller, Aug 10, 2009, in forum: Python
    Replies:
    8
    Views:
    310
    Steven D'Aprano
    Aug 11, 2009
Loading...

Share This Page