python动态import

Ⅰ pythonimport值改变后是否影响原对象

影响。
python中import值改变后会影陆袭响原对象。因为import会将模块中的早如兄变量和函数导入到当前程序中，如果模块中的变量和函数的值发生改变，那么这些变量和函数在当前程序中也会发生改变橡判。
Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆于1990年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。

Ⅱ 请教Python 从 egg 中 import so 文件的正确姿势

我写了一个包，用

python setup.py install

安装后会在site-package目录下得到一个.egg 的文件，然后可以在 python 中 import 这个包。 问题是，我在setup.py文件中包含了 package_data，是一个名为xxx.so的动态库文件，这个库文件在 install 之后也被正确包含进那个.egg 文件里了（把.egg 重命名成.zip 解压后可以确认）。 但是，如果只用这个.egg 文件，那么包里的一行代码

from . import xxx

就会报错

ImportError: cannot import name 'xxx'

奇怪的是，如果我重命名.zip 然后解压成文件夹，from . import xxx就能正常加载那个动态库了。

请问熟悉 Python 的 V 友这种情况该如何解决？谢谢！

我后来在`setup.py`中的`setup()`中加入了一条`zip_safe=False`来生成 folder 而不是 egg，解决了问题，但不知道有没有更优雅的解决方案？

Ⅲ Python如何将生成的代码/函数保存进文件并导入

Python具备动态导入mole并且执行其中代码的能力，所以你只要import你保存的东西就可以，无需中断你当前的代码执行流。

Ⅳ 有哪些python引包的方法

python引包的三种方法：1、输入“import 包名”命令导入;2、输入“from 包名 import 模块名”命令导入;3、输入“from 包名.模块名 import 成员名”导入。

包其实本质上乎明是模块，因此导入模块的语法同样也适用于导入包。无论导入我们自定义的包，还是导入从他处下载的第三方包，导入方法可归结为以下 3 种：

import 包名[.模块名 [as 别名]]

from 包名 import 模块名 [as 别名]

from 包名.模块名 import 成员名 [as 别名]

用 [] 括起来的部分，是可选部分，即可以使用，也可以直接忽略。

注意，导入包的同时，会在包目录下生成一个含有 __init__.cpython-36.pyc 文件的 __pycache__ 文件夹。

1、python引包的方法——import 包名[.模块名岁猛告 [as 别名]]

以 my_package 包为例，导入 mole1 模块并使用该模块中成员可以使用如下代码：

import my_package.mole1

my_package.mole1.display("http://c.biancheng.net/java/")

运行结果为：

http://c.biancheng.net/java/

可以看到，通过此语法格式导入包中的指定模块后，在使用该模块中的成员(变量、函数、类)时，需添加“包名.模块名”为前缀。当然，如果使用 as 给包名.模块名”起一个别名的话，就使用直接使用这个别名作为前缀使用该模块中的方法了，例如：

import my_package.mole1 as mole

mole.display("http://c.biancheng.net/python/")

程序执行结果为：

http://c.biancheng.net/python/

另外，当直接导入指定包时，程序会自动执行该包所对应文件夹下的 __init__.py 文件中的代码。例如：

import my_package

my_package.mole1.display("http://c.biancheng.net/linux_tutorial/")

直接导入包名，并不会将包中所有模块全部导入到程序中，它的作用仅仅是导入并执行包下的 __init__.py 文件，因此，运行该程序，在执行 __init__.py 文件中代码的同时，还会抛出 AttributeError 异常(访问的对象不存在)：

http://c.biancheng.net/python/

Traceback (most recent call last):

File "C:UsersmengmaDesktopdemo.py", line 2, in

my_package.mole1.display("http://c.biancheng.net/linux_tutorial/")

AttributeError: mole 'my_package' has no attribute 'mole1'

我们知道，包的本质就知圆是模块，导入模块时，当前程序中会包含一个和模块名同名且类型为 mole 的变量，导入包也是如此：

import my_package

print(my_package)

print(my_package.__doc__)

print(type(my_package))

创建第一个 Python

2、python引包的方法——from 包名 import 模块名 [as 别名]

以导入my_package 包中的 mole1 模块为例，使用此语法格式的实现代码如下：

from my_package import mole1

mole1.display("http://c.biancheng.net/golang/")

运行结果为：

http://c.biancheng.net/python/

http://c.biancheng.net/golang/

可以看到，使用此语法格式导入包中模块后，在使用其成员时不需要带包名前缀，但需要带模块名前缀。

当然，我们也可以使用 as 为导入的指定模块定义别名，例如：from my_package import mole1 as molemole.display("http://c.biancheng.net/golang/")

此程序的输出结果和上面程序完全相同。

同样，既然包也是模块，那么这种语法格式自然也支持 from 包名 import * 这种写法，它和 import 包名 的作用一样，都只是将该包的 __init__.py 文件导入并执行。

3、python引包的方法——from 包名.模块名 import 成员名 [as 别名]

此语法格式用于向程序中导入“包.模块”中的指定成员(变量、函数或类)。通过该方式导入的变量(函数、类)，在使用时可以直接使用变量名(函数名、类名)调用，例如：

from my_package.mole1 import display

display("http://c.biancheng.net/shell/")

运行结果为：

http://c.biancheng.net/python/

http://c.biancheng.net/shell/

当然，也可以使用 as 为导入的成员起一个别名，例如：

from my_package.mole1 import display as dis

dis("http://c.biancheng.net/shell/")

该程序的运行结果和上面相同。

另外，在使用此种语法格式加载指定包的指定模块时，可以使用 * 代替成员名，表示加载该模块下的所有成员。例如：

from my_package.mole1 import *

display("http://c.biancheng.net/python")

以上就是《python引包的方法有哪些？这三种方法才是你最需要的》的全部内容，Python是一种动态解释的、强类型定义语言:编写它时不需要定义变量类型，运行时变量类型被强制固定，如果你想知道更多的python的相关方法，可以点击本站的其他文章进行学习。

Ⅳ python内置函数

python内置函数是什么？一起来看下吧：

python内置函数有：

abs：求数值的绝对值
>>>abs(-2) 2
pmod：返回两个数值的商和余数

>>>pmod(5,2) (2,1) >>pmod(5.5,2) (2.0,1.5)
bool:根据传入的参数的逻辑值创建一个布尔值

>>>bool() #未传入参数 False >>>bool(0) #数值0、空序列等值为False False >>>bool(1) True
all：判断可迭代对象的每个元素是否都为True值
>>>all([1,2]) #列表中每个元素逻辑值均为True,返回True True >>> all(()) #空元组 True >>> all({}) #空字典 True
help：返回对象的帮助信息
>>> help(str)  Help on class str in mole builtins: class str(object) |  str(object='') -> str |  str(bytes_or_buffer[, encoding[, errors]]) -> str |   |  Create a new string object from the given object. If encoding or |  errors is specified, then the 雹清object must expose a data buffer |  that will be decoded using the given encoding and error handler. |  Otherwise, returns the result of object.__str__() (if defined) |  or repr(object). |  encoding defaults to sys.getdefaultencoding(). |  errors defaults to 'strict'. |   |  Methods defined here: |   |  __add__(self, value, /)           Return self+value.
_import_：动态导入模块
index = __import__('index') index.sayHello()
locals：返回当前作用域内的局部变量和其值组成的字典
>>> def f():     print('before define a ')     print(locals()) #作用域内无变量     a = 1     print('after define a')     print(locals()) #作用域内有一个a变量，值为1 >>> f>>> f() before define a  {}  after 磨枝define a {'a': 1}
input：读取用户输入值
>>瞎肆敏> s = input('please input your name:') please input your name:Ain >>> s 'Ain'
open：使用指定的模式和编码打开文件，返回文件读写对象
# t为文本读写，b为二进制读写 >>> a = open('test.txt','rt') >>> a.read() 'some text' >>> a.close()
eval：执行动态表达式求值
>>> eval('1+2+3+4') 10

除了上述举例的函数之外，内置函数按分类还可分为：

1、数学运算（7个）

2、类型转换（24个）

3、序列操作（8个）

4、对象操作（7个）

5、反射操作（8个）

6、变量操作（2个）

7、交互操作（2个）

8、文件操作（1个）

9、编译操作（4个）

10、装饰器（3个）

Ⅵ pythonimport什么可以不用定义其他模块

Python import 指令可以用来导碧行入模块，而不需要定义其他模块。例如，你可以在脚本中使用import语句来加载标准库模块，第三方模块和自定义模块，而不需悔拆哗要定义御唯其他模块。

Ⅶ Python 中的import 机制

解释器 在执行语句时，遵循作用域原则。因为这和作用域有关系， 如果在顶层导入模块，此时它的作用域是全局的；如果在函数内部导入了模块，那它的作用域只是局部的 ，不能被其它函数使用。如果其它函数也要用到这个模块，还需要再次导入比较麻烦。

在用import语句导入模块时最好按照这样的顺序：

绝对路径 就是文件的真正存在的路径，是指从硬盘的根目录(盘符)开始，进行一级级目录指向文件。
相对路径 就是以当前文件为基准进行一级级目录指向被引用的资源文件。

以下是常用的表示当前目录和当前目录的父级目录的标识符

形如from moleB import ClassB语句，根据Python内部import机制，执行细分步骤：

总结：from moleB import ClassB有两个过程，先from mole，后import ClassB。

当然将moleA.py语句 from moleB import ClassB改为：import moleB，将在第二次执行moleB.py语句from moleA import ClassA时报错：ImportError: cannot import name ‘classA’

在一个文件下同时有 init .py文件、和其他模块文件时，该文件夹即看作一个包（package）。包的导入 和模块导入基本一致，只是导入包时，会执行这个 init .py，而不是模块中的语句。
而且，如果只是单纯地导入包【形如：import xxx】，而包的 init .py中有没有明确地的其他初始化操作，则：此包下的模块 是不会被自动导入的。当然该包是会成功导入的，并将包名称放入当前.py的Local命名空间中。

参考文章：
Python中import机制
Python 3.x可能是史上最详解的【导入（import）】
在Python中以绝对路径或者相对路径导入文件的方法
Python的模块引用和查找路径

Ⅷ python用set需要import

在python用import或者from...import或者from...import...as...来导入相应的模块，作用和使用方法与C语言的include头文件类似。其实就是引入某些成熟的函数库和成熟的方法，避免重复造轮子，提高开发速度。

python的import方法可以引入系统的模块，也可以引入我们自己写好的共用模块，这点和php非常相似，但是它们的具体细节还不是很一样。首轮盯因为php是在引入的时候指明引入文件的具体路径，而python中不能够写文件路径进行引入。

下面总结一下import的几种情况：

python包含子目录中的模块方法比较简单，关键者和是能够在sys.path里面找到通向模块文件的路径。

下面将具体介绍几种常用情况:

(1)主程序与模块程序在同一目录下:

如下面程序结构:

`-- src

|-- mod1.py

`-- test1.py

若在程序test1.py中导入模块mod1, 则直接使用import mod1或from mod1 import *;

(2)主程序所在目录是模块所在目录的父(或祖辈)目录

如下面程序结构:

`-- src

|-- mod1.py

|-- mod2

| `-- mod2.py

`-- test1.py

若在程序test1.py中导入模块mod2, 需要在mod2文件夹中建立空文件__init__.py文件(也可以在该文件中自定义输出模块接口); 然后使用 from mod2.mod2 import * 或import mod2.mod2.

(3)主程序导入上层目录中模块或其他目录(平级)下的模块

如下面程序结构:

`-- src

|-- mod1.py

|-- mod2

| `-- mod2.py

|-- sub

| `-- test2.py

`-- test1.py

若在程序test2.py中导入模块mod1和mod2。首先需要在mod2下建立__init__.py文件(同(2))，src下不必建立该文件。然后调用方式如下:

下面程序执行方式均在程序文件所在目录下执行，如test2.py是在cd sub;之后执行python test2.py

而test1.py是在cd src;之后执行python test1.py; 不保证桐宽在src目录下执行python sub/test2.py成功。

import sys

sys.path.append("..")

import mod1

import mod2.mod2

Ⅸ 如何使用Python动态控制Linux系统的内存占用百分比

如何使用Python动态控制Linux系统的内存占用百分比?

近期有网上朋友寻求帮助：如何通过脚本动态控制Linux系统的内存占用百分比？经过一番网络+编写调试，终于初步完成了动态控制Linux系统内存占用百分比。现写出来以帮助更多的朋友。
1 前言
根据需求是动态控制Linux系统内存占用百分比，比如当前内存占用30%，如果设置内存占用为70%，则需要申请内存使达到占用70%；如果再降低到40%，则需要释放部分申请的内存。其实脚本的本质是内存动态申请与释放。
注意：因为Python脚本运行之前内存有一定占用，故设定内存占用不能低于该百分比。
2 内存动态申请
通过查询资料，使用Python动态申请内存块，可以使用ctypes包中的函数，导入包及代码如下所示：
>>> from ctypes import *
>>> mem=create_string_buffer(1024)
说明：内存申请使用create_string_buffer()函数，上面申请了1024字节的内存块。
下面演示申请100MB内存前后变化
申请前如下图所示：

使用代码如下：
>>>mem=create_string_buffer(104857600)
申请后如下图所示：

从上述两幅图中可以看出，申请内存前内存占用295MB，申请后内存占用397MB，增加了约100MB内存占用。
3 内存动态释放
由于Python对内存是有垃圾回收机制的，采用对象引用计数方式。当对象的引用计数为0时，启动垃圾回收GC。此处内存动态释放就是使用该原理。
代码如下：
>>> mem=None
释放后内存占用如下图所示：

内存占用由397MB降低到297MB，释放了100MB内存占用。
说明：将None赋值给对象mem后，mem对象的引用计数即为0，此时垃圾回收启动，释放mem对象占用的内存。
4 系统总内存、占用内存检测
由于需要设定内存占用百分比，故需要获取系统总物理内存和占用内存。本文使用的方法是读取系统文件“/proc/meminfo”，从中解析出总内存大小以及当前内存占用大小等内存相关的信息。该文件内容格式如下图所示：

代码片段如下所示：
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)< 2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
说明：按行读取meminfo文件内容，创建字典对象mem，将meminfo文件第一列设置为mem对象的键值，将meminfo文件第二列数字设置为mem对象的值。
5 获取用户输入百分比
通过读取键盘输入字符串，然后转换为数字实现接收用户输入的百分比，代码如下所示：
input_str=raw_input("Input UsedMemory`s Rate or q to exit:")
rate=float(input_str)
注意：此处键盘输入的都是字符串，需要进行字符串转换为数字，使用float()或long()函数进行转换。
6 动态设置内存占用百分比测试
测试使用两个Python脚本文件，分别是test.py和mem_rate.py，其功能分别是查看当前内存占用和动态设定内存占用百分比。如下图所示：

注意：上述两个文件需要使用“chmod +x *.py”修改为可执行属性。
6.1 查看当前内存占用
查看当前内存占用百分比，使用上述test.py文件，运行命令为“./test.py”，运行结果如下图所示：

当前使用内存为320MB，占用百分比为17%。
6.2 动态设置内存占用百分比
动态设置内存占用百分比使用上述mem_rate.py脚本，注意该脚本文件第一行代码为“#!/usr/bin/python2.6”，表示该脚本使用python2.6程序运行。该行需要修改为待运行Linux系统中Python实际的安装程序路径。
动态内存百分比设置界面如下图所示：

处于待输入状态。另外显示了当前内存占用（321MB），总内存大小（1869MB）以及内存占用百分比（17%）。
如果此时设置内存占用百分比为80%，则脚本会每次申请10MB空间，直至内存占用接近或等于80%为止。如下图所示：

内存申请过程如下图所示：

内存申请过程中占用百分比变化为：35%，45%，56%，70%，…
mem_rate.py运行过程如下图所示：

内存申请过程中占用变化为：1461MB，1471MB，1481MB，1491MB。
此时如果内存占用百分比设置为20%，则需要释放一部分内存。
test.py脚本运行过程如下图所示：
由于释放内存运行较快，抓取到最后结果

内存占用为20%。
mem_rate.py脚本运行过程如下图所示：

内存释放过程中内存占用为：413MB，403MB，393MB，383MB，最后内存占用稳定在20%，383MB。
输入“q”或“Q”退出内存占用百分比设定过程，如下图所示：

此时内存占用如下图所示：

内存占用恢复到运行mem_rate.py脚本之前状态，17%，321MB。

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※
附：完整Python脚本代码
test.py
------------------------------------------------------------------------------------------------
#!/usr/bin/python2.6
def memory_stat():
mem = {}
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)< 2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
# - mem['Buffers']- mem['Cached']
return mem

mem=memory_stat()
print("Used(MB):%d"%(long(mem['MemUsed'])/1024/1024))
print("Rate:%d%%"%(100*long(mem['MemUsed'])/float(mem['MemTotal'])))

§§§§§§§§§§§§§§§§§§§§§§§§§§
mem_rate.py
---------------------------------------------------
#!/usr/bin/python2.6

from ctypes import *

# Get Memory Info(Total, Used... Byte)
def get_memory_stat():
mem = {}
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)< 2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
# Return MemroyInfo Object
return mem

# Get Simple Memory Info
def get_memory_info(mem):
# Byte -> MB
n=1024* 1024
used=float(mem['MemUsed'])/ n
total=float(mem['MemTotal'])/ n
rate=used/total* 100
smp={'used':used,'total':total,'rate':rate}
return smp

# Display Current Memory Info
def print_memory_info(mem):
# Get SimpleMemory Info
smp=get_memory_info(mem)
print("Used(MB):%d\tTotal(MB):%d\tUsedRate:%d%%"%(smp['used'], smp['total'], smp['rate']))

# Get Rate Of Memory Used To Be Setted(Integer Formate)
def input_memory_used_rate(org_rate):
# Byte -> MB
n=1024* 1024
while(True):
mem=get_memory_stat()
print_memory_info(mem)

input_str=raw_input("Input UsedMemory`s Rate or q to exit:")
if(len(input_str)== 0):
continue
if("q"== input_str):
info={'rate':0,'used':mem['MemUsed']/ n}
return info
if("Q"== input_str):
info={'rate':0,'used':mem['MemUsed']/ n}
return info
try:
rate=float(input_str)
if((rate>=org_rate)and (rate<=95)):
info={'rate':rate,'used':mem['MemUsed']/ n}
return info
else:
print("Please inputa valid number(%d%%~95%%)."%(org_rate))
except:
print("Please inputa valid number(%d%%~95%%)."%(org_rate))

# Set Rate Of Memory Used
def set_memory_used_rate(new_rate, total, pre_used,list):
if(new_rate==0):
return None
dest_mem=total* new_rate /100.0
# 10MB
mb10=10485760
n_chg=10
# Free Memory OrAllocate Memory ?
is_new=dest_mem>pre_used
cur_used=pre_used
while(True):
# To Calc FreeMemory Or Allocate Memory ?
need_new=dest_mem-n_chg>=pre_used
need_del=dest_mem+n_chg<=pre_used

# Need To AllocateMemory
if(is_new):
if(need_new):
p=create_string_buffer(mb10)
list.append(p)
dest_mem=dest_mem-n_chg
cur_used=cur_used+n_chg
else:
return"end"
# Need To FreeMemory
else:
idx=len(list)-1
if(need_deland (idx>=0)):
p=list[idx]
del list[idx]
p=None
dest_mem=dest_mem+n_chg
cur_used=cur_used-n_chg
else:
return"end"
print("****** MemoryUsed(MB):%d"%(cur_used))

# Entry Of Program

# List Of Memory Object, 10MB Of One Object
list=[]
# Get Current Memory Info
mem=get_memory_stat()
# Get Simple Memory Info
smp=get_memory_info(mem)
org_rate=smp['rate']
total=smp['total']

while(True):
# Get Rate OfMemory To Be Used
info=input_memory_used_rate(org_rate)
new_rate=float(info['rate'])
pre_used=float(info['used'])
# Set Rate OfMemory To Be Used
rtn=set_memory_used_rate(new_rate, total, pre_used, list)
if(not rtn):
print("bye!")
exit()

Ⅹ python中模块导入的方法

Python中模块导入的方法有import、from…茄伏枝import和import as三种。import可以导入整个模块颤敏，from…import可以只导入模块的指定部分，而import as则可以将模块重命名。
拓展：此外，Python还支持动态厅耐加载模块，如importlib.import_mole()方法可以动态加载模块，可以根据程序的需要动态加载指定的模块。