Understanding import

本文介绍如何使用Python标准库创建并导入动态模块。通过理解和利用Python的import机制,可以在运行时构造模块,并将其插入到sys.modules中,从而实现按需加载模块的功能。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Understanding import

import hello
hello.say_hello(
 

 

The first thing we need to understand to do this is how Python’s import mechanism works; in other words, the exact steps Python goes through when it encounters an import statement. If you want all the gory details, the official Python documentation on importing isn’t too bad an explanation of this process, and Fredrik Lundh has an excellent write-up of all the nooks and crannies of Python’s importing mechanism . I highly recommend giving both of those a thorough read at some point, but for now let’s walk through the key points together.

When you have a statement like import hello in a Python program, Python goes through two steps to actually import it:

  1. Locate and, if necessary, initialize the module.
  2. Bind the resulting module object to a name in your current scope.

So when Python sees import hello , it wants to locate and possibly initialize a module named hello , then assign the resulting module object to the name hello in your program’s current scope. If the import statement ocurs at the top of a file, hello will become a module-global name, for example.

The first step — locating and initializing the module — can happen in either of a couple of ways:

  1. If the module hasn’t already been initialized, that needs to happen. For most Python modules, that simply consists of executing the code in the module so that, for example, any classes or functions it contains get defined.
  2. If the module has already been initialized, there will be a module object already in memory for it, and Python can simply grab that object.

Python figures out whether the module has already been initialized by looking at a dictionary named modules which lives inside the built-in module “sys” of the Python standard library; sys.modules has keys corresponding to the import paths of modules which have already been loaded and initialized, and the values are the resulting module objects.

So the actual mechanism is pretty simple: when we say import hello in a Python program, Python goes and looks for the key “hello” in the sys.modules dictionary. If that key exists, Python gets the already-initialized module object out of sys.modules[‘hello’] , and if it doesn’t then Python goes out to your file system and starts looking through the directories on your Python import path for a file or module named hello , which will — if found — be initialized and create an entry in sys.modules . If it isn’t found, Python will raise an ImportError .

One important thing to note here is that if you have a module which can conceivably be imported in multiple different ways — say, because both your project directory and application are directly on your Python path, so that both from myproject.blog.models import Entry and from blog.models import Entry will work — you can end up with a single module getting initialized more than once, and having more than one entry in sys.modules (one for each different way you’ve imported it). Significant sections of Django’s model-loading code exist to work around this and ensure that a given model class only gets initialized once.

Also, note that for module names which contain dots (e.g., import foo.bar ), the mechanism is slightly different: Python looks for an entry in sys.modules which matches up to, but not including, the right-most dot, then looks inside the resulting module object for the final part. So in the statement import foo.bar.baz , Python looks for the entry “foo.bar” in sys.modules , then looks for something named baz inside the resulting module object.

By now you might be wondering whether, since sys.modules is a dictionary, you can just go stick things into it. The answer is that you can: you’re free to do anything to sys.modules that’s legal to do to a Python dictionary, though it’s almost always a bad idea to go messing around with it. But this points the way to how we’re going to make our eventual import statement work: once we’ve constructed the hello module, we can simply stick it into sys.modules and Python will happily let us import it without ever bothering to check if an actual module of that name exists on the file system.

Understanding modules

If you’ve ever tried to access, say, a nonexistent Django setting, you’ve probably seen an error like this:

AttributeError: 'module' object has no attribute 'some_random_name'


And so far I’ve been using the phrase “module object” to refer to Python modules. Both of these give us a clue about how we can build a module on the fly: modules, like everything else in Python, are simply objects, and you can instantiate new module objects just as you can instantiate objects from classes you’ve defined in your applications, assuming you know where to look.

The place to look is another module from Python’s standard library : types , which contains the type objects for many of Python’s built-in types. If you know your way around the types module, you can dynamically build nearly any sort of standard Python object on the fly, even some objects that you can’t normally construct otherwise. In this case the one we’re interested in is types.ModuleType , which we can use to create a brand-new module object at runtime; it works the same as instantiating any other object, and requires at least one argument: the name of the module object to create. You can also optionally pass a second argument which will become the new module’s docstring, so that Python’s built-in help() function will be able to show documentation for it (and other automated documentation parsers will be able to extract its documentation), but we’ll leave that off for this example.

So let’s go ahead and start building our hello module. Pop open a Python interpreter and type in the following:

import types
hello_mod = types ModuleType('hello')
 

We now have a module object bound to the variable hello_mod ; you can check that it really is a module and has the correct name — “hello” — in the interpreter:

hello_mod<module 'hello' (built-in)>
 

At this point, the new module is simply a blank slate; we can stick anything into it that we like. So let’s define the say_hello() function we’re going to use:

def say_hello():
    print "Hello"
 

And then add it to our hello module:

hello_mod.say_hello = say_hello
 

You can call this function and verify that it works:

hello_mod.say_hello()
 

Putting it all together

Of course, we still need to make our new module importable via the name “hello”, but armed with an understanding of sys.modules this is easy:

import sys
sys.modules.setdefault('hello', hello_mod)

>>><module 'hello' (built-in)>
 

We’re using setdefault() here instead of assigning directly to sys.modules[‘hello’] , because if there’s already a loaded module named hello we shouldn’t overwrite it; the setdefault() method of a Python dictionary takes a key and and a value, and then either inserts the value into the dictionary with the given key, if that key wasn’t already in use in the dictonary, or else does nothing to the dictionary. In either case it returns the value which ends up in the dictionary, which provides an easy way to figure out if you added a new value or not. In this case, the return value of setdefault() was the module we just created, so we know it was added to sys.modules successfully.

And now we can use the “magic”:

import hello
 
hello.say_hello()

>>>Hello

 

This works because our dynamically-created module object is now in sys.modules under the name “hello”; since it’s in there, Python will simply return it any time we say import hello and never bother checking the file system to see if a “real” module of that name exists on the Python path. We can even use the alternate from syntax to import just the say_hello() function:

from hello import say_hello
say_hello()

>>>Hello
 

Once again, Python is simply giving us back the contents of the module object we created in memory; the fact that it exists in sys.modules again bypasses any need to check the file system. And as soon as you exit the Python interpreter, the hello module will simply disappear; since it only ever existed in memory inside this single Python process, it will go away as soon as that Python process exits.

And now you know

At this point you can probably work out how Django — back in the 0.90 and 0.91 days — used to create the “magic” model modules which were importable from django.models ; there was a lot more work going on to build up the things which eventually lived inside that module, but ultimately it boiled down to the same two things we just did: createing a new module object with types.ModuleType , and making it importable by inserting it into sys.modules .

I can’t stress enough that this is something you probably shouldn’t ever do in real-world code, because — as the example of Django’s old-style model system shows — it’s confusing and counterintuitive to mysteriously create modules where people aren’t expecting them. And messing with sys.modules , unless you really know what you’re doing, can also be dangerous; if you’re not careful you might accidentally delete or overwrite the entry for a module you were relying on, and then you’ll be in a real pickle.

But knowing how the process works — even if you never actually use it — helps to turn this from “magic” into a fairly straightforward application of a Python feature, and provides a useful glimpse into some of Python’s fundamental workings: knowing how Python’s import mechanism works, for example, is incredibly important and handy for a broad range of Python programming tasks, and shows off a major part of Python’s sometimes-downplayed dynamic nature.

### 视频理解中的关键技术与概念 视频理解是指使计算机能够解析并解释视频内容的过程。这不仅涉及静态图像的理解,还包括时间维度上的动态分析。 #### 计算机视觉作为基础工具 计算机视觉系统充当感知器的角色,为决策提供必要的信息[^1]。该领域旨在赋予计算机超越人类水平的知觉能力[^2]。对于视频数据而言,这意味着不仅要处理单帧内的空间关系,还要考虑跨多帧的时间连续性和变化模式。 #### 场景理解和语义分割 场景理解是从给定输入图像中提取有意义且具信息量的视觉特征的过程。此过程可以通过图卷积网络(GCNs)[^3]来实现高效的特征捕捉和分类。这些方法同样适用于视频流,在每一帧上执行相似的操作,并利用相邻帧之间的关联性增强整体表现。 ```python import cv2 from tensorflow.keras.models import load_model def preprocess_frame(frame): """预处理函数用于调整大小和其他必要转换""" processed = cv2.resize(frame, (width, height)) return np.array([processed]) model = load_model('path_to_pretrained_model') cap = cv2.VideoCapture(video_path) while cap.isOpened(): ret, frame = cap.read() if not ret: break # 预测当前帧的内容类别分布 predictions = model.predict(preprocess_frame(frame)) # 进一步处理预测结果... ``` 这段Python代码展示了如何加载预先训练好的模型并对来自摄像头或其他源的一系列帧进行实时分类。虽然这里只显示了一个简单的例子,但在实际应用中可能会涉及到更复杂的架构设计和技术细节。 #### 时间序列建模与时序数据分析 除了每秒几十张图片组成的二维平面外,视频本质上是一个三维的数据集——宽度×高度×时间轴。因此,有效地表示和操作这种结构化数据成为了一项挑战。常用的方法有循环神经网络(RNN),长短时记忆单元(LSTM)以及最近兴起的关注机制(Attention Mechanism)等,它们都可以帮助捕获长时间跨度内发生的事件及其相互作用规律。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值