python編譯參數
1. python 「編譯的」 Python 文件的理解是什麼
為了加快載入模塊的速度,Python 會在 __pycache__ 目錄下以 mole.version.pyc 名字緩存每個模塊編譯後的版本,這里的版本編制了編譯後文件的格式。它通常會包含 Python 的版本號。例如,在 CPython 3.3 版中,spam.py 編譯後的版本將緩存為 __pycache__/spam.cpython-33.pyc。這種命名約定允許有不同發布和不同版本的 Python 編譯的模塊同時存在。
Python 會檢查源文件與編譯版的修改日期以確定它是否過期並需要重新編譯。這是完全自動化的過程。同時,編譯後的模塊是跨平台的,所以同一個庫可以在不同架構的系統之間共享。
Python 不檢查在兩個不同環境中的緩存。首先,它會永遠重新編譯而且不會存儲直接從命令行載入的模塊。其次,如果沒有源模塊它不會檢查緩存。若要支持沒有源文件(只有編譯版)的發布,編譯後的模塊必須在源目錄下,並且必須沒有源文件的模塊。
部分高級技巧:
為了減少一個編譯模塊的大小,你可以在 Python 命令行中使用 -O 或者 -OO。-O 參數刪除了斷言語句,-OO 參數刪除了斷言語句和 __doc__ 字元串。
因為某些程序依賴於這些變數的可用性,你應該只在確定無誤的場合使用這一選項。「優化的」 模塊有一個 .pyo 後綴而不是 .pyc 後綴。未來的版本可能會改變優化的效果。
來自 .pyc 文件或 .pyo 文件中的程序不會比來自 .py 文件的運行更快;.pyc 或 .pyo 文件只是在它們載入的時候更快一些。
compileall 模塊可以為指定目錄中的所有模塊創建 .pyc 文件(或者使用 -O 參數創建 .pyo 文件)。
在 PEP 3147 中有很多關這一部分內容的細節,並且包含了一個決策流程。
2. python 中os.system()的用法
os模塊中的system()函數可以方便地運行其他程序或者腳本。
語法如下:os.system(command)
其參數含義如下所示:
command 要執行的命令,相當於在Windows的cmd窗口中輸入的命令。如果要向程序或者腳本傳遞參數,可以使用空格分隔程序及多個參數。
(2)python編譯參數擴展閱讀
Python在執行時,首先會將.py文件中的源代碼編譯成Python的byte code(位元組碼),然後再由Python Virtual Machine(Python虛擬機)來執行這些編譯好的byte code。這種機制的基本思想跟Java,.NET是一致的。然而,Python Virtual Machine與Java或.NET的Virtual Machine不同的是,Python的Virtual Machine是一種更高級的Virtual Machine。
這里的高級並不是通常意義上的高級,不是說Python的Virtual Machine比Java或.NET的功能更強大,而是說和Java 或.NET相比,Python的Virtual Machine距離真實機器的距離更遠。或者可以這么說,Python的Virtual Machine是一種抽象層次更高的Virtual Machine。
基於C的Python編譯出的位元組碼文件,通常是.pyc格式。
除此之外,Python還可以以交互模式運行,比如主流操作系統Unix/Linux、Mac、Windows都可以直接在命令模式下直接運行Python交互環境。直接下達操作指令即可實現交互操作。
3. LINUX下要在C中嵌入Python,編譯的時候怎樣解決庫的連接問題
gcc編譯時,當使用動態庫編譯可以按照幾種寫法1.gcctest.c./libSDL2-2.so2.gcctest.c-lSDL2-23.gcctest.c-L/home/test-lSDL2-2一般的編譯參數都是按照2或3去寫2寫法的含義是從/lib或者/usr/lib目錄下尋找名稱為SDL2-2的庫,即尋找/lib/libSDL2-2.so或者/usr/lib/libSDL2-2.so文件進行鏈接,當然如果沒有動態庫就會去找靜態庫,再沒有應該就會在編譯時報錯3寫法的含義是從-L參數首先從指定的目錄中尋找需要鏈接的庫文件,隨後再去尋找系統文件夾中是否存在需要的庫1寫法的含義是將當前目錄下的./libSDL2-2.so.0文件鏈接進最終文件,因此執行readelf-aa.out後在動態庫部分所看到的路徑就是./libSDL2-2.so.0,進而在執行文件時僅會從當前目錄下尋找libSDL2-2.so.0文件,當執行文件時所在的目錄下沒有該文件時就會出現找不到庫文件的操作你第二次操作時,因為function.so庫文件與a.out文件在同一個目錄,同時也是在該目錄下執行的ldd操作及運行a.out,a.out在載入動態庫時從當前目錄下找到了所需要的庫文件,此時能夠執行成功(ldd命令實質是一個腳本,通過設置環境變數運行動態庫鏈接器來輸出所有待鏈接的動態庫)。你可以試試將a.out拷貝至其他目錄再次運行,將出現和第一次操作時一樣的現象,找不到function.so文件。具體的解決方法就是修改編譯參數,將./libSDL2-2.so.0修改為-lSDL2-2並將libSDL2-2.so.0文件拷貝至/usr/lib目錄下,並且可能因為沒有修改鏈接器的緩存文件(將可能找不到帶版本號後綴的動態庫),需要在/usr/lib目錄下建立一個文件連接(ln-slibSDL2-2.so.0libSDL2-2.so)或者直接修改名稱為libSDL2-2.so
4. Python中定義函數默認參數值的使用注意事項
4.7.1. 默認參數值
最常用的一種形式是為一個或多個參數指定默認值。這會創建一個可以使用比定義是允許的參數更少的參數調用的函數,例如:
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = input(prompt)
if ok in ('y', 'ye', 'yes'):
return True
if ok in ('n', 'no', 'nop', 'nope'):
return False
retries = retries - 1
if retries < 0:
raise OSError('uncooperative user')
print(complaint)
這個函數可以通過幾種不同的方式調用:
只給出必要的參數:
ask_ok('Do you really want to quit?')
給出一個可選的參數:
ask_ok('OK to overwrite the file?', 2)
或者給出所有的參數:
ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')
這個例子還介紹了 in 關鍵字。它測定序列中是否包含某個確定的值。
默認值在函數 定義 作用域被解析,如下所示:
i = 5
def f(arg=i):
print(arg)
i = 6
f()
將會輸出 5。
重要警告: 默認值只被賦值一次。這使得當默認值是可變對象時會有所不同,比如列表、字典或者大多數類的實例。例如,下面的函數在後續調用過程中會累積(前面)傳給它的參數:
def f(a, L=[]):
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
這將輸出:
[1]
[1, 2]
[1, 2, 3]
如果你不想讓默認值在後續調用中累積,你可以像下面一樣定義函數:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
5. Python程序如何使用參數
用sys模塊,使用sys.argv接收參數,sys.argv是一個列表,第2個元素開始是傳遞進來的值,傳遞的時候用空格割開就好
import sys
for x in sys.argv:
....print(x)
6. 請教Scons python 編譯問題
一、概述
scons是一個Python寫的自動化構建工具,和GNU make相比優點明顯:
1、移植性:python能運行的地方,就能運行scons
2、擴展性:理論上scons只是提供了python的類,scons使用者可以在這個類的基礎上做所有python能做的事情。比如想把一個已經使用了Makefile大型工程切換到scons,就可以保留原來的Makefile,並用python解析Makefile中的編譯選項、源/目標文件等,作為參數傳遞給scons,完成編譯。
3、智能:Scons繼承了autoconf/automake的功能,自動解析系統的include路徑、typedef等;「以全局的觀點來看所有的依賴關系」
二、scons文件
scons中可能出現的文件:
SConstruct,Sconstruct,sconstruct,SConscript
scons將在當前目錄以下次序 SConstruct,Sconstruct,sconstruct 來搜索配置文件,從讀取的第一個文件中讀取相關配置。
在配置文件SConstruct中可以使用函數SConscript()函數來定附屬的配置文件。按慣例,這些附屬配置文件被命名為」SConscript」,當然也可以使用任意其它名字。
三、scons的命令行參數
scons: 執行SConstruct中腳本
scons -c clean
scons -Q 只顯示編譯信息,去除多餘的列印信息
scons -Q --implicit-cache hello 保存依賴關系
--implicit-deps-changed 強制更新依賴關系
--implicit-deps-unchanged 強制使用原先的依賴關系,即使已經改變
四、SConstruct提供的方法
1、Program:生成可執行文件
Program('hello.c') 編譯hello.c可執行文件,根據系統自動生成(hello.exe on Windows; hello on POSIX)
Program('hello','hello.c') 指定Output文件名(hello.exe on Windows; hello on POSIX)
Program(['hello.c', 'file1.c', 'file2.c']) 編譯多個文件,Output文件名以第一個文件命名
Program(source = "hello.c",target = "hello")
Program(target = "hello" , source = "hello.c")
Program('hello', Split('hello.c file1.c file2.c')) 編譯多個文件
Program(Glob("*.c"))
src = ["hello.c","foo.c"];Program(src)
2、Object:生成目標文件
Object('hello.c') 編譯hello.c目標文件,根據系統自動生成(hello.obj on Windows; hello.o on POSIX)
3、Library:生成靜態/動態庫文件
Library('foo', ['f1.c', 'f2.c', 'f3.c']) 編譯library
SharedLibrary('foo', ['f1.c', 'f2.c', 'f3.c']) 編譯 shared library
StaticLibrary('bar', ['f4.c', 'f5.c', 'f6.c']) 編譯 static library
庫的使用:
Program('prog.c', LIBS=['foo', 'bar'], LIBPATH='.') 連接庫,不需加後綴或是前綴
4、SourceSignatures:判斷源文件是否修改
SourceSignatures('MD5') 根據內容是否改變,默認方式
SourceSignatures('timestamp') 根據修改時間
5、TargetSignatures:判斷目標文件是否改變
TargetSignatures('build') 根據編譯結果
TargetSignatures('content') 根據文件內容,如果只是加了句注釋,將不會被重新編譯
6、Ignore:忽略依賴關系
Ignore(hello, 'hello.h') 忽略某個依賴關系
7、Depends:明確依賴關系
Depends(hello, 'other_file') 明確依賴關系
8、SConscript:scons的配置文件。
源文件的目錄結構如下:
src:
| SConstruct
|test.cpp
| mA(目錄):
| SConscript
| func.cpp
其中test.cpp為主文件,中調用func.cpp中定義的函數
SConstruct內容如下:
[cpp]view plain
subobj=SConscript(['mA/SConscript'])
obj=subobj+Object(Glob("*.cpp"))
Program("test",list(obj))
- SConscript內容 :
obj=Object(Glob("*.cpp"))
Return("obj")
- 上例中,在主目錄中執行 scons就可以編譯整個"工程"。SConstruct編譯主目錄中的test.cpp,並通過SConscript編譯mA目錄下的源文件,並最終生成可執行文件;SConscript用於編譯mA中的func.cpp並把生成的func.o傳遞給主目錄的SConstruct。
env=Environment()
dict=env.Dictionary()
keys=dict.keys()
keys.sort()
forkeyinkeys:
print"constructionvariable='%s',value='%s'"%(key,dict[key])
- 環境變數的使用:
- env = Environment() #創建默認的環境變數,默認scons會按編譯器的默認選項來進行編譯
- import os
- env = Environment(CC = 'gcc',CCFLAGS = '-O2') #創建並設置環境 變數
- env.Program('foo.c')
env=Environment()
flags=env.ParseFlags(['-pthread-I/usr/include/stlport','-L.'])
env.MergeFlags(class_flags)
subobj=SConscript(['mA/SConscript'])
obj=subobj+env.Object(Glob("*.cpp"))
env.Program("test",list(obj),LIBS=['libstlport.a'])
obj=Object(Glob("*.cpp"))
Return("obj")
env=Environment()
flags=env.ParseFlags(['-pthread-I/usr/include/stlport','-L.'])
env.MergeFlags(class_flags)
Export('env')
subobj=SConscript(['mA/SConscript'],exports='env')
obj=subobj+env.Object(Glob("*.cpp"))
env.Program("test",list(obj),LIBS=['libstlport.a'])
- mA/SConscript:
[cpp]view plain
10.env:環境變數
環境變數用於設置在編譯過程中的各種參數,可以用下面的SConstruct列印環境變數的所有信息(實際上env就是一個python字典)
可以使用如下的SConstruct查看環境變數的內容:
[cpp]view plain
環境變數的復制:
env = Environment(CC = 'gcc')
opt = env.Clone(CCFLAGS = '-O2')
dbg = env.Clone(CCFLAGS = '-g')
環境變數的替換:
env = Environment(CCFLAGS = '-DDEFINE1')
env.Replace(CCFLAGS = '-DDEFINE2')
env.Program('foo.c')
環境變數的輸入輸出:用於統一多目錄源文件的編譯選項,如:
src:
| SConstruct
| libstlport.a
| test.cpp
| include(目錄):
| foo.h
| mA(目錄):
| SConscript
|func.cpp
test.cpp和mA/func.cpp都引用了include/foo.h,test.cpp調用了mA/func.cpp的功能函數,其中include/foo.h中定義了一個包含string類型的類。
SConstruct如下:
[cpp]view plain
mA/SConscrip如下:
[cpp]view plain
不出意外的話上邊的工程編譯可以通過,但是運行的時候會Aborted。因為test.cpp,mA/func.cpp都使用了包含string類型的那個類,但是由於編譯環境的不同,test.cpp認為string變數的大小是24位元組, mA/func.cpp認為string變數的大小是4個位元組(libstlport.a搗的鬼)。
解決問題的辦法就是環境變數輸出,修改SConstruct和mA/SConscript如下:
SConstruct:
[cpp]view plain
7. 編譯python的enable-shared是什麼意思
這是 configure 常用的一個參數,表示啟用動態庫版本。 如果你要編譯一個庫的源代碼,可以把它編譯成靜態庫,也可以把它編譯成動態庫。如果你想編譯成靜態庫,就用 --enable-shared參數;如果你想編譯成靜態庫,就用--enable-static參數。
8. python 函數參數的類型
1. 不同類型的參數簡述
#這里先說明python函數調用得語法為:
復制代碼
代碼如下:
func(positional_args,
keyword_args,
*tuple_grp_nonkw_args,
**dict_grp_kw_args)
#為了方便說明,之後用以下函數進行舉例
def test(a,b,c,d,e):
print a,b,c,d,e
舉個例子來說明這4種調用方式得區別:
復制代碼
代碼如下:
#
#positional_args方式
>>>
test(1,2,3,4,5)
1 2 3 4 5
#這種調用方式的函數處理等價於
a,b,c,d,e = 1,2,3,4,5
print a,b,c,d,e
#
#keyword_args方式
>>>
test(a=1,b=3,c=4,d=2,e=1)
1 3 4 2 1
#這種處理方式得函數處理等價於
a=1
b=3
c=4
d=2
e=1
print a,b,c,d,e
#
#*tuple_grp_nonkw_args方式
>>>
x = 1,2,3,4,5
>>> test(*x)
1 2 3 4
5
#這種方式函數處理等價於
復制代碼
代碼如下:
a,b,c,d,e = x
print
a,b,c,d,e
#特別說明:x也可以為dict類型,x為dick類型時將鍵傳遞給函數
>>> y
{'a': 1,
'c': 6, 'b': 2, 'e': 1, 'd': 1}
>>> test(*y)
a c b e d
#
#**dict_grp_kw_args方式
>>>
y
{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}
>>> test(**y)
1 2 6
1 1
#這種函數處理方式等價於
a = y['a']
b = y['b']
... #c,d,e不再贅述
print
a,b,c,d,e
2.
不同類型參數混用需要注意的一些細節
接下來說明不同參數類型混用的情況,要理解不同參數混用得語法需要理解以下幾方面內容.
首先要明白,函數調用使用參數類型必須嚴格按照順序,不能隨意調換順序,否則會報錯. 如 (a=1,2,3,4,5)會引發錯誤,;
(*x,2,3)也會被當成非法.
其次,函數對不同方式處理的順序也是按照上述的類型順序.因為#keyword_args方式和**dict_grp_kw_args方式對參數一一指定,所以無所謂順序.所以只需要考慮順序賦值(positional_args)和列表賦值(*tuple_grp_nonkw_args)的順序.因此,可以簡單理解為只有#positional_args方式,#*tuple_grp_nonkw_args方式有邏輯先後順序的.
最後,參數是不允許多次賦值的.
舉個例子說明,順序賦值(positional_args)和列表賦值(*tuple_grp_nonkw_args)的邏輯先後關系:
復制代碼
代碼如下:
#只有在順序賦值,列表賦值在結果上存在羅輯先後關系
#正確的例子1
>>> x =
{3,4,5}
>>> test(1,2,*x)
1 2 3 4 5
#正確的例子2
>>>
test(1,e=2,*x)
1 3 4 5 2
#錯誤的例子
>>> test(1,b=2,*x)
Traceback (most recent call
last):
File "<stdin>", line 1, in <mole>
TypeError: test()
got multiple values for keyword argument 'b'
#正確的例子1,處理等價於
a,b = 1,2 #順序參數
c,d,e = x #列表參數
print a,b,c,d,e
#正確的例子2,處理等價於
a = 1 #順序參數
e = 2 #關鍵字參數
b,c,d = x #列表參數
#錯誤的例子,處理等價於
a = 1 #順序參數
b = 2 #關鍵字參數
b,c,d = x
#列表參數
#這里由於b多次賦值導致異常,可見只有順序參數和列表參數存在羅輯先後關系
函數聲明區別
理解了函數調用中不同類型參數得區別之後,再來理解函數聲明中不同參數得區別就簡單很多了.
1. 函數聲明中的參數類型說明
函數聲明只有3種類型, arg, *arg , **arg 他們得作用和函數調用剛好相反.
調用時*tuple_grp_nonkw_args將列表轉換為順序參數,而聲明中的*arg的作用是將順序賦值(positional_args)轉換為列表.
調用時**dict_grp_kw_args將字典轉換為關鍵字參數,而聲明中**arg則反過來將關鍵字參數(keyword_args)轉換為字典.
特別提醒:*arg
和 **arg可以為空值.
以下舉例說明上述規則:
復制代碼
代碼如下:
#arg, *arg和**arg作用舉例
def
test2(a,*b,**c):
print a,b,c
#
#*arg 和
**arg可以不傳遞參數
>>> test2(1)
1 () {}
#arg必須傳遞參數
>>>
test2()
Traceback (most recent call last):
File "<stdin>", line 1,
in <mole>
TypeError: test2() takes at least 1 argument (0 given)
#
#*arg將順positional_args轉換為列表
>>>
test2(1,2,[1,2],{'a':1,'b':2})
1 (2, [1, 2], {'a': 1, 'b': 2})
{}
#該處理等價於
a = 1 #arg參數處理
b = 2,[1,2],{'a':1,'b':2} #*arg參數處理
c =
dict() #**arg參數處理
print a,b,c
#
#**arg將keyword_args轉換為字典
>>>
test2(1,2,3,d={1:2,3:4}, c=12, b=1)
1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:
4}}
#該處理等價於
a = 1 #arg參數處理
b= 2,3 #*arg參數處理
#**arg參數處理
c =
dict()
c['d'] = {1:2, 3:4}
c['c'] = 12
c['b'] = 1
print
a,b,c
2. 處理順序問題
函數總是先處理arg類型參數,再處理*arg和**arg類型的參數.
因為*arg和**arg針對的調用參數類型不同,所以不需要考慮他們得順序.
復制代碼
代碼如下:
def test2(a,*b,**c):
print
a,b,c
>>> test2(1, b=[1,2,3], c={1:2, 3:4},a=1)
Traceback (most
recent call last):
File "<stdin>", line 1, in
<mole>
TypeError: test2() got multiple values for keyword argument
'a'
#這里會報錯得原因是,總是先處理arg類型得參數
#該函數調用等價於
#處理arg類型參數:
a = 1
a = 1
#多次賦值,導致異常
#處理其他類型參數
...
print a,b,c
>>> def foo(x,y):
... def bar():
... print
x,y
... return bar
...
#查看func_closure的引用信息
>>> a =
[1,2]
>>> b = foo(a,0)
>>>
b.func_closure[0].cell_contents
[1, 2]
>>>
b.func_closure[1].cell_contents
0
>>> b()
[1, 2] 0
#可變對象仍然能被修改
>>> a.append(3)
>>>
b.func_closure[0].cell_contents
[1, 2, 3]
>>> b()
[1, 2, 3] 0
9. python如何通過命令行輸入參數
形式一:直接在命令行輸入參數
第一個紅色框為命令行參數
第二個框為控制台模式(Terminal)
形式二:在編譯工具中配置參數
點擊運行:點擊紅色框 編輯配置
如下圖:紅色框即為設置的命令行參數