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()方法可以動態載入模塊，可以根據程序的需要動態載入指定的模塊。