Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Are circular dependencies possible in Python?

Reply
Thread Tools

Are circular dependencies possible in Python?

 
 
Tim Tyler
Guest
Posts: n/a
 
      04-09-2005
Like C, Python seems to insist I declare functions before calling
them - rather than, say, scanning to the end of the current script
when it can't immediately find what function I'm referring to.

C lets you predeclare functions to allow for the existence of
functions with circular dependencies.

Does Python allow you to do something similar?

If not how do you create functions with circular dependencies in
Python - where function A could call function B; and function
B could call function A - or is that not possible?
--
__________
|im |yler http://timtyler.org/ http://www.velocityreviews.com/forums/(E-Mail Removed) Remove lock to reply.
 
Reply With Quote
 
 
 
 
Dave Brueck
Guest
Posts: n/a
 
      04-09-2005
Tim Tyler wrote:
> Like C, Python seems to insist I declare functions before calling
> them - rather than, say, scanning to the end of the current script
> when it can't immediately find what function I'm referring to.


Yes and no. Yes, they have to exist before you can use them (that only makes
sense), but no, they don't have to be placed in the same order in the source
code like they do with C:

>>> def A(count):

.... print 'A', count
.... B(count + 1)
....
>>> def B(count):

.... print 'B', count
.... if count < 10:
.... A(count + 1)
....
>>> B(0)

B 0
A 1
B 2
....

See - all that matters is that they exist before you call them.

-Dave
 
Reply With Quote
 
 
 
 
Michael Spencer
Guest
Posts: n/a
 
      04-09-2005
Tim Tyler wrote:
> Like C, Python seems to insist I declare functions before calling
> them - rather than, say, scanning to the end of the current script
> when it can't immediately find what function I'm referring to.
>
> C lets you predeclare functions to allow for the existence of
> functions with circular dependencies.
>
> Does Python allow you to do something similar?
>
> If not how do you create functions with circular dependencies in
> Python - where function A could call function B; and function
> B could call function A - or is that not possible?

Of course, for example:

def A(*args):
if len(args) > 1:
print "Calling B%s" % repr(args[1:])
return B(*args[1:])
else:
print "A Called with: %s" % args[0]

def B(*args):
if len(args) > 1:
print "Calling A%s" % repr(args[1:])
return A(*args[1:])
else:
print "B Called with: %s" % args[0]

>>> A("Arg1","Arg2","Arg3","Arg4")

Calling B('Arg2', 'Arg3', 'Arg4')
Calling A('Arg3', 'Arg4')
Calling B('Arg4',)
B Called with: Arg4
>>>


Functions have to exist before you call them, but they are not 'declared'. def
and its enclosed suite is a statement, like print, while, etc... The def
statement is executed to define the function. For functions defined at module
level, this statement is executed when the module is first imported (or
reloaded) in source-code order along with any other module-level code.

Executing a def statement compiles (but does not execute) the body of the
function. Each function, when def'd also gets a reference to the global scope
in which it is defined. When you execute the function body (by calling the
function), identifiers that are not resolved in the functions own local scope
are looked up in this global scope.

So in the example above, the body of A calls B. B is not defined in A's local
scope, so it is looked up in A's globals, which is the module. As long as def
B(... has been executed in the same module before you first call A, everything
is fine.


Michael

 
Reply With Quote
 
Dan Sommers
Guest
Posts: n/a
 
      04-09-2005
On Sat, 9 Apr 2005 15:57:15 GMT,
Tim Tyler <(E-Mail Removed)> wrote:

> Like C, Python seems to insist I declare functions before calling them
> - rather than, say, scanning to the end of the current script when it
> can't immediately find what function I'm referring to.


Python has no such restriction.

The only restriction is that the function be defined before it is
called. Unlike C, function definitions in Python are executable
statements.

If your script looks like this:

f( ) # call f

def f( ) # define f
print 'hello'

then it will fail because f has not yet been defined before it was
called.

> Does Python allow you to do something similar?


No. Python has no such thing as a function declaration.

> If not how do you create functions with circular dependencies in
> Python - where function A could call function B; and function
> B could call function A - or is that not possible?


Perhaps if you can post a minimal example that shows us what you're
running into, someone here will know how to help.

HTH,
Dan

--
Dan Sommers
<http://www.tombstonezero.net/dan/>
μ₀ × ε₀ × c² = 1
 
Reply With Quote
 
Tim Tyler
Guest
Posts: n/a
 
      04-09-2005
Tim Tyler <(E-Mail Removed)> wrote or quoted:

> Like C, Python seems to insist I declare functions before calling
> them - rather than, say, scanning to the end of the current script
> when it can't immediately find what function I'm referring to.
>
> C lets you predeclare functions to allow for the existence of
> functions with circular dependencies.
>
> Does Python allow you to do something similar?
>
> If not how do you create functions with circular dependencies in
> Python - where function A could call function B; and function
> B could call function A - or is that not possible?


Thanks guys - that's made how Python works in this area abundantly clear.
--
__________
|im |yler http://timtyler.org/ (E-Mail Removed) Remove lock to reply.
 
Reply With Quote
 
Marc 'BlackJack' Rintsch
Guest
Posts: n/a
 
      04-09-2005
In <(E-Mail Removed)>, Tim Tyler wrote:

> Like C, Python seems to insist I declare functions before calling
> them - rather than, say, scanning to the end of the current script
> when it can't immediately find what function I'm referring to.


They don't have to be declared but to be *defined* in Python before you
can call them. A ``def`` is executed in Python -- a function object is
given a name. The content of a Python script is executed in the order the
code is written.

> C lets you predeclare functions to allow for the existence of
> functions with circular dependencies.
>
> Does Python allow you to do something similar?


Yes, just define the function before it gets actually called::

def func_a(n):
if n > 5:
return
else:
func_b(n + 1)

def func_b(n):
print n
func_a(n + 1)

func_a(0)

What happens here is

1. Define function A. That function B doesn't exist by now is no problem
because it is not called yet. There's just the instruction to call it if
the body of function A is executed. *Then* function B has to exist.

2. Define function B. You can swap both definitions without problems.

3. Function A is actually called and *must* exist at this point.

Ciao,
Marc 'BlackJack' Rintsch
 
Reply With Quote
 
John Machin
Guest
Posts: n/a
 
      04-10-2005
On Sat, 9 Apr 2005 15:57:15 GMT, Tim Tyler <(E-Mail Removed)> wrote:

>Like C, Python seems to insist I declare functions before calling
>them


One is left wondering what gave you that impression about Python.
Nothing could be further from the truth. The only construct in Python
that smells anything like a declaration is the wartish "global". The
Python philosophy is that everything is dynamic. You don't muck about
with declarations; you just get on with the job. See example below,
where we have a list of functions, which of course all follow the same
protocol, but what that protocol is is of no concern of the Python
compiler.

def nothing_to_declare(data_fields, validation_funcs, other_info):
for k, fld in enumerate(data_fields):
validation_funcs[k](fld, k, other_info)

Aside: How many iterations would it take for the average C programmer
to get the declaration for "validation_funcs" correct?

Others have pointed out that "def" is executed. So is "class". An OO
example of dynamism would be a bit longer, but would involve creating
classes on the fly and stuffing into them whatever methods are
required for the task at hand.

HTH,

John

 
Reply With Quote
 
Tim Tyler
Guest
Posts: n/a
 
      04-10-2005
Marc 'BlackJack' Rintsch <(E-Mail Removed)> wrote or quoted:
> In <(E-Mail Removed)>, Tim Tyler wrote:


> > Like C, Python seems to insist I declare functions before calling
> > them - rather than, say, scanning to the end of the current script
> > when it can't immediately find what function I'm referring to.

>
> They don't have to be declared but to be *defined* in Python before you
> can call them. [...]


That makes three of you who have called me on my use of "declare".

AFAICT, I was using the standard dictionary definition of this word:

http://dictionary.reference.com/search?q=declare

The term "declare" doesn't have the same meaning as the term "predeclare".
--
__________
|im |yler http://timtyler.org/ (E-Mail Removed) Remove lock to reply.
 
Reply With Quote
 
John Machin
Guest
Posts: n/a
 
      04-10-2005
On Sun, 10 Apr 2005 07:34:02 GMT, Tim Tyler <(E-Mail Removed)> wrote:

>Marc 'BlackJack' Rintsch <(E-Mail Removed)> wrote or quoted:
>> In <(E-Mail Removed)>, Tim Tyler wrote:

>
>> > Like C, Python seems to insist I declare functions before calling
>> > them - rather than, say, scanning to the end of the current script
>> > when it can't immediately find what function I'm referring to.

>>
>> They don't have to be declared but to be *defined* in Python before you
>> can call them. [...]

>
>That makes three of you who have called me on my use of "declare".
>
>AFAICT, I was using the standard dictionary definition of this word:
>
> http://dictionary.reference.com/search?q=declare
>
>The term "declare" doesn't have the same meaning as the term "predeclare".


We don't need no steenking dictionaries; we're using "declare" and
"define" in the same manner as did K&R:

int foo(int bar); /* declaration */

int foo(int bar) { /* definition */
return 42 * bar;
}



 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Circular dependencies in Templates - better solution? ro86 C++ 4 03-06-2005 10:10 PM
Circular dependencies ernesto basc?n pantoja C++ 2 11-29-2004 08:03 PM
circular dependencies and typedefs Dylan C++ 7 07-07-2004 06:59 PM
circular dependencies, unrecognized base types, oh-my crichmon C++ 3 06-28-2004 03:03 AM
Re: circular dependencies & globals - avoid w/ precompiler directives?betterdesign suggestions? Suzanne Vogel C++ 2 06-26-2003 12:25 AM



Advertisments