當前位置：首頁 » 編程語言 » python封裝調用

python封裝調用

發布時間: 2021-03-14 05:02:27

㈠我想自己寫一個python函數封裝成SDK方便以後調用，但是在這個函數編寫引入了不少import包，該怎麼操作

寫最上面。寫裡面有可能會重復import同一個包，浪費內存

㈡ Python如何把一段代碼封裝起來重復使用

你可以用類或者函數將其封裝一下，將需要後期變動的變數作為參數放在其中，可以使用默認值傳參。

舉個簡單函數和類的栗子：

#函數封裝
defsum(a,b=3):
returna+b
#類封裝
classS(object):
def__init__(self,a=2,b=3)
self.a=a
self.b=b
defsum(self):
returnself.a+self.b

㈢ python封裝調用問題，求解，一直顯示找不到元素

python封裝調用問題，求解，一直顯示找不到元素？
他日相逢與

㈣ Python寫好的演算法代碼，下一步用C還是C++進行重寫封裝給別人調用比較好

底層都用py了，上面還管什麼效率
用什麼都一樣
c/c++/py隨你喜歡了

㈤如何將C++的API封裝成python可調用形式

在C++的庫上面套一層就可以了。
可以包裝成CPython模塊，也可以包裝成C庫然後用ctypes、cffi調用。
要對付主要是是C++的函數命名和類型。
包裝CPython模塊可以看手冊里「Extending and Embedding」的部分。只要保證initMODULENAME（2.x）或PyInit_MODULENAME（3.x）是extern "C"的就行，手冊里的例子用了PyMODINIT_FUNC這個宏，已經自動給加好了。
包裝C庫就是把所有函數都聲明成extern "C"的，把傳遞的C++類型以C類型替代。舉個例子

namespace enemy {

void first_blood(int id);

} // namespace enemy

void double_kill();
void double_kill(int killer);

class Silencer
{
public:
std::string watch_and_learn();
};

包裝之後大概是這樣的：

extern "C" {

void enemy_first_blood(int id)
{
enemy::first_blood(id);
}

void double_kill_by_roshan()
{
double_kill();
}

void double_kill_by_hero(int killer)
{
double_kill(killer);
}

void* new_silencer()
{
return new Sliencer;
}

void silencer_watch_and_learn(void *instacne, char *buffer)
{
std::string what = reinterpret_cast<Silencer*>(instance)->watch_and_learn();
strcpy(buffer, what.c_str());
}

void release_silencer(void *instacne)
{
delete reinterpret_cast<Silencer*>(instance);
}

} // extern "C"

㈥我現在想把自己寫的python模塊源代碼封裝成dll，然後在別的python腳本里調用，可以嗎

可以的，只要把python模塊轉換成dll模塊，利用Python自帶的ctypes模塊載入調用就行。

ctypes 是Python的外部函數庫。它提供了與 C語言兼容的數據類型，並允許調用 DLL 或共享庫中的函數。可使用該模塊以純 Python 形式對這些庫進行封裝。

ctypes導出了cdll對象，在 Windows 系統中還導出了windll和oledll對象用於載入動態鏈接庫。通過操作這些對象的屬性，你可以載入外部的動態鏈接庫。cdll載入按標準的cdecl調用協議導出的函數，而windll導入的庫按stdcall調用協議調用其中的函數。

(6)python封裝調用擴展閱讀：

載入調用DLL的相關方法：

1、載入DLL

載入的時候要根據你將要調用的函數是符合什麼調用約定的。

stdcall調用約定：兩種載入方式

Objdll = ctypes.windll.LoadLibrary("dllpath")

Objdll = ctypes.WinDLL("dllpath")

cdecl調用約定：也有兩種載入方式

Objdll = ctypes.cdll.LoadLibrary("dllpath")

Objdll = ctypes.CDLL("dllpath")

其實windll和cdll分別是WinDLL類和CDll類的對象。

2、調用dll中的方法

載入dll的時候會返回一個DLL對象（假設名字叫Objdll），利用該對象就可以調用dll中的方法。 e.g.如果dll中有個方法名字叫Add（注意如果經過stdcall聲明的方法，如果不是用def文件聲明的導出函數或者extern 「C」聲明的話，編譯器會對函數名進行修改，這個要注意。）

調用：nRet = Objdll.Add(12, 15) 即完成一次調用。

㈦ java 做的 api 通過那種語言能封裝成 python 能調用的動態鏈接庫

解析器使用Jython, 可以直接調用java api

㈧ Python中的封裝有什麼作用

日常生活中可以看到很多的汽車，汽車包括車輪、發動機、車架等零部件。可以在車架上安裝車輪，然後安裝發動機，最後安裝其他零件，刷漆。就形成了汽車。這個過程，是把各種零件放到車架上的過程。但思考一下，對於開車的人，需要關注車的內部結構嗎?答案顯然是否定的。汽車對外提供了方向盤、油門等去調用內部結構從而進行行駛。由這個例子可以總結出，汽車就是各種零件經過封裝得到的產物，同時提供給駕駛人操控汽車需要的介面設備。這就是生活中的封裝。

我們可以看到生活中的封裝有很多好處。具體有如下的幾條好處：

①隱藏了實現細節，在使用時沒必要關注具體實現。

②安全性好，內部細節隱藏了，就不能隨意破壞。

③對外提供介面方便使用。

④可維護性好，方便修改實現，修改完成後，對外介面不變，對用戶使用無影響。

⑤方便重用，任何一個會開車的人都可以駕駛汽車，只要對外的介面相同就行了。

總之，封裝就是將抽象得到的屬性和方法形成「類」，並將類內部信息進行隱藏，對外公開介面的機制。封裝限制從類外訪問，從而提升代碼安全性和可維護性。

封裝的內涵是把抽象得到的屬性和方法進行了封裝，對於方法，隱藏了具體的實現，提供了方法名供使用者調用。對於成員變數也進行隱藏，通過方法對外提供訪問介面。通過封裝，限制了直接訪問成員變數，通過方法，增加驗證邏輯，提高了安全性和可維護性。

封裝的外延是按照內聚性、一致性、封裝性、清晰性、完整性進行類的封裝。

內聚性就是類應該描述一個單一的實體。例如，學生姓名和教師所帶班級不是單一實體的屬性，不能組合在一個類中。

一致性就是類、成員變數、方法名要有意義，並且順序是成員變數、構造方法、普通方法。

封裝性就是類中成員變數是私有屬性，通過getter/setter訪問。

清晰性是指類的結構應該是易於解釋和理解的。

完整性是需要充分考慮多種不同用戶設計，應該能通過屬性和方法提供多種方案以適應用戶不同需求。例如，字元串中有很多方法，同時這些方法可以組合完成各種任務。

關於Python的基礎問題可以看下這個網頁的視頻教程，網頁鏈接，希望我的回答能幫到你。

㈨測試新人如何使用Python代碼封裝自動化測試的用例

如何使用Python和實現自動化測試？
本文我將詳細介紹使用Appium下的Python編寫的測試的例子代碼對一個iOS的樣例應用進行測試所涉及的各個步驟，而對Android應用進行測試所需的步驟與此非常類似。
然後按照安裝指南，在你的機器上安裝好Appium。
我還需要安裝Appium的所有依賴並對樣例apps進行編譯。在Appium的工作目錄下運行下列命令即可完成此任務：
$ ./reset.sh --ios
編譯完成後，就可以運行下面的命令啟動Appium了：
$ grunt appium
現在，Appium已經運行起來了，然後就切換當前目錄到sample-code/examples/python。接著使用pip命令安裝所有依賴庫(如果不是在虛擬環境virtualenv之下，你就需要使用sudo命令)：
$ pip install -r requirements.txt
接下來運行樣例測試：
$ nosetests simple.py
既然安裝完所需軟體並運行了測試代碼，大致了解了Appium的工作過程，現在讓我們進一步詳細看看剛才運行的樣例測試代碼。該測試先是啟動了樣例應用，然後在幾個輸入框中填寫了一些內容，最後對運行結果和所期望的結果進行了比對。首先，我們創建了測試類及其setUp方法：
classTestSequenceFunctions(unittest.TestCase):

defsetUp(self):
app=os.path.join(os.path.dirname(__file__),
'../../apps/TestApp/build/Release-iphonesimulator',
'TestApp.app')
app=os.path.abspath(app)
self.driver=webdriver.Remote(
command_executor='127.0.0.1:4723/wd/hub',
desired_capabilities={
'browserName':'iOS',
'platform':'Mac',
'version':'6.0',
'app': app
})
self._values=[]
「desired_capabilities」參數用來指定運行平台(iOS 6.0)以及我們想測試的應用。接下來我們還添加了一個tearDown方法，在每個測試完成後發送了退出命令：
deftearDown(self):
self.driver.quit()
最後，我們定義了用於填寫form的輔助方法和主測試方法：
def_populate(self):
# populate text fields with two random number
elems=self.driver.find_elements_by_tag_name('textField')
foreleminelems:
rndNum=randint(0,10)
elem.send_keys(rndNum)
self._values.append(rndNum)
deftest_ui_computation(self):
# populate text fields with values
self._populate()
# trigger computation by using the button
buttons=self.driver.find_elements_by_tag_name("button")
buttons[0].click()
# is sum equal ?
texts=self.driver.find_elements_by_tag_name("staticText")
self.assertEqual(int(texts[0].text),self._values[0]+self._values[1])
本文介紹到此，相信很多朋友都已經明白了。但是如果你對Nose和Python來運行Appium測試有任何問題或看法，可以給我留言，我們可以繼續交流。

㈩如何用Python封裝C語言的字元串處理函數

在C語言中，字元串處理是每天都要面對的問題。我們都知道C語言中其實並沒有一種原生的字元串類型，『字元串』在C語言里只是一種特殊的以''結尾的字元數組。因此，如何將C語言與更高層次的Python語言在『字元串』處理這個問題上對接是一個有難度的問題。所幸有swig這種強大的工具。

如何封裝一個函數，它修改參數字元串的內容

假如有這樣一個C語言的函數，

void FillZero(char* pc,size_t * piLen)
{
size_t i=0;
while(i++<*piLen/2 )
*pc++ = '0';
*pc = 0;
*piLen = i+1;
}

這個函數的功能是把字元串變成n個0。不過我們更關注函數的形式。這樣的函數，表面上看char* pc是函數的參數，可是實際上它才是函數的返回值和執行的結果。piLen這個參數既是pc的最大長度，也是新的字元串的長度。我們直接用python封裝，看看運行結果。

Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> s='123456'
>>> cchar.FillZero(s,6)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: in method 'FillZero', argument 2 of type 'size_t *'

結果差強人意，不是我們想要得到的結果。函數的第二個參數為size_t* 我們很難用python來表示，而且python中也不存在既是輸入，也是輸出的參數。

swig有一個標准庫，其中有一個cstring.i文件就是用來解決C語言字元串類型的問題。

我們在.i文件中加入這樣幾行

%include "cstring.i"
%cstring_output_withsize(char* pc,size_t* pi)
void FillZero(char* pc, size_t* pi);

然後運行看結果

Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> cchar.FillZero(10)
'00000\x00'
>>> s=cchar.FillZero(10)
>>> print s
00000

我們看函數的變化。首先在python里， FillZero變成了只有一個參數的函數。然後函數的返回值變成了一個字元串。其實cstring_output_size其實是一個宏，通過這個宏的定義改變了函數的形式，直接在Python中得到我們想要的結果。

其實類似cstring_output_size的宏還有好幾個，我列舉一下:

cstring_output_allocate(char *s,free($1));
第一個參數是指向字元串地址的指針，第二個參數為釋放空間的方法。
大家考慮這一下這樣的函數：
void foo(char* & s)
{

s = (char*)malloc(10);
memcpy(s,"123456789",9);

}

s這個參數表面上看是輸入，實際上是函數真正的輸出。函數中真正改變的東西是char&s指向的字元串的值。而且char&這個類型,

python或者其他腳本語言里應該都沒有對應的類型。那麼我們用cstring_output_allocate將這個函數轉換成另外一個形式的python或者其他腳本語言的函數。轉換後的函數其實是這樣的，以python為例str
foo()。

%mole a
%include "cstring.i"
%{
void foo(char*& s);
%}
%cstring_output_allocate(char *&s, free(*$1));
void foo(char *&s);

在python中的調用：


>>> import a
>>> a.foo()
'123456789'
>>>

cstring_output_maxsize(char *path, int maxpath);
第一個參數也是可以改變的字元串首地址，第二個參數為字元串的最大長度。在Python中調用的時候，只有maxpath這個參數，返回字元串。
cstring_output_allocate(char *s, free($1));
第一個參數為指向字元串首地址的指針，第二個參數為釋放指針的方法。這個宏主要是封裝一種直接在函數內部malloc空間的函數。在Python中調用時沒有參數，直接返回字元串。
cstring_output_allocate_size(char *s, int slen, free(*$1));
這個相當於前面兩個函數的組合。在函數內部malloc空間，然後將字元串長度通過slen返回。其實在調用的時候非常簡單，沒有參數，直接返回字元串。

如何處理c++的std::string

std::string是C++標准類庫STL中常見的類。在平時工作中大家肯定是沒少用。在python中如何封裝std::string? swig提供了標准庫

例如函數:

string Repeat(const string& s)
{
return s+s;
}

只要在swig中加入這樣幾行：

%include "std_string.i"
using namespace std;
string Repeat(const string& s);

運行結果：

Python 2.6.6 (r266:84292, Dec 27 2010, 00:02:40)
[GCC 4.4.5] on linux2
Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> cchar.Repeat('123')
'123123'

使用起來很方便，但需要注意的是，假如函數的參數的內容是可以被修改，就不能用這種方式封裝。
例如:

void repeat(string s)
{
s+=s;
}

這樣的函數直接使用 'std_string.i' 就是無效的。遇到這種函數，只能用C語言封裝成 void repeat(chars, int maxsize), 再用swig調用 'cstring_output_withsize' 這個宏再封裝一次了。

閱讀全文

python封裝調用

與python封裝調用相關的閱讀推薦