Home / Questions / 510310
Accepted
Candid Moe
Asked: 2022-06-21 23:37:55 +0800 CST 2022-06-21 23:37:55 +0800 CST

Is "import XXX" the same as "from XXX import a, b, c"?

  • 772

I understood that

import XXX
print(XXX.a)

Y

from XXX import a, b, c
print(a)

they were the same, and choosing one over the other was a matter of personal preference.

The thing is, I have this module servicio.pythat contains the mockup of a service that reads some data and keeps it in the variable var.

Every time the service is called, varit should be updated, which I simulate by adding 100 to it on each pass.

service.py

var = 1

def cambia():
    global var
    var += 100
    print(f"cambia var = {var}")

From another module I want to call the service and then retrieve the value by directly accessing the variable var.

Alternative 1

import servicio

print(id(servicio.var), servicio.var)
servicio.cambia()
print(id(servicio.var), servicio.var)

which produces:

9788992 1
cambia var = 101
9792192 101

Alternative 2

from servicio import var, cambia

print(id(var), var)
cambia()
print(id(var), var)

which produces:

9788992 1
cambia var = 101
9788992 1

Can someone explain the difference to me?

python

3 Answers

  1. Best Answer

    importAs you've already found out "the hard way" those are not equivalent syntaxes . But what is the difference exactly?

    import servicio

    what it does is load the file servicio.pyinto memory, execute it, and create in the local namespace the symbol servicio, which acts as if it were an object, in the sense that it supports the "dot" syntax to access its internal symbols, so so you can put servicio.var, servicio.cambia, etc. All symbols that you servicio.pydefine at the global()global level (operates at the module level), are accessible from the code that imports them through the "dot" notation.

    instead when you do

    from servicio import var

    what happens is that, as before, it is loaded servicio.pyinto memory, executed, and the symbol is created in the local namespacevar .

    Simplifying a lot, it is as if it had been done:

    import servicio
var = servicio.var
del servicio         # Esto borra el símbolo

    So we now have two vardifferent symbols, with different visibility:

    1. The symbol varthat is listed if you do globals()inside servicio.pyand that was created as a result of the line var=1in that file.
    2. The symbol varthat is listed if you do globals()inside main.py, and that was created as a result of the from servicio import var. This starts initialized with the value 1. I guess you won't be too surprised to discover that if we did var = 2that , it would main.pyonly change the value of the local symbol, without affecting the symbol described in point 1.

    When the function cambia()does var+=100, it is actually changing the value of symbol 1 of the two explained above. The value of symbol 2 is not affected, as it is in another namespace.

    When you do the you do import servicion't see these side effects because you are always referring to the 1 symbol, by having to use the servicio.valor.

    Note : Looking id()at the variables does not help much here, and rather it is confusing, because basically id()what it returns is a kind of hash of the value it contains. It actually returns the memory address where the corresponding data is, but not the address of the variable , which is probably what you wanted to find out. There is no way to get the address of the variable in python, and the address of the data doesn't help because it obviously changes if you change the value of the variable.

    • 6

  2. It's not exactly the same. The difference between from a import be import a(or even import a.b) lies in what it does at the reference level.

    import awhat it does is import the module aand create a reference in the current namespace

    from a import bimport the module aand create a reference tob

    What happens when we do from a import b, c?

    The interpreter imports aand creates two different references to bya c, generating situations like the ones you describe.

    Although they are objects from the same module, they are referenced separately.

    • 3

  3. Symbolically, what you are doing in alternativa 1corresponds to inheriting the characteristics of a "parent node" let 's call it PadreA(a class object)... When you subsequently use:

    print(id(servicio.var), servicio.var)
servicio.cambia()
print(id(servicio.var), servicio.var)

    From the "nodes" you would be doing something like:

    método(PadreA.child1)
método(PadreA.child2)
método(PadreA.child1)

    Note that if it PadreAstored some kind of memory such that it changes with each execution, like a counter (at the end I mention that it is more likely in this case), it would be different than the second alternative:

    método(PadreA.child1)
método(PadreB.child2)
método(PadreA.child1)

    Because you would only be calling parent nodeA twice and not three times.

    Another difference, as @abulafia mentions, is that with the first alternative you are inheriting all the methods of the class... so it PadreAwould have Nchildren, where N is the number of methods of the module.

    Instead, alternative two; PadreBIt would only have the direct child of the method you called. It would only have 1method (not Nlike in the first alternative).

    * Clarification: These are conclusions that I have drawn from my personal use of classes and modules, I have no proof but I think it makes a lot of sense.

    Among other things, being redundant, trying with servicio.pylike:

    import random

random.seed(0)
var=random.randint(1,100)
    
def cambia():
    global var

    var=random.randint(1,100)
    print(f"cambia var = {var}")

    The output is replicated, using a debugger the objects in memory are checked (alternative 1): enter image description here

    Which contains a single instance of an object, two different methods are called from the same instance.

    and alternative 2: enter image description here

    In summary:

    • Alternative 1 uses two features (a variable and a method) from the same instance.
    • Alternative 2 uses two different instances of the same class for the same thing.

    *What actually happens is that alternative 2, when executed in different instances, have no relationship, and is unable to modify the variable var, it turns out to have the same one idsince it has not changed

    • 0