python相互引用
⑴ python 兩模塊互相引用的問題
如果你執行father的話，這個時候father是__main__，不是mole，所以會執行到father的from son import *，這個時候python會去執行son.py，而son.py一開始就是from father import *，所以python又去執行father.py，因為father.py的一開始是from son import *，並且因為之前執行過了，所以這個時候son已經在sys.moles裡面，所以python不會重新執行son.py，而只是把sys.moles裡面的son返回給你，所以當執行到father.py的print(x)的時候，還沒有執行son.py裡面的x=6，所以會有找不到x的attribute error。
解決的辦法就是最好根本不要有circular import。
⑵ 【python-C相互調用】python里的dict如何作為參數傳入.so中的c語言函數
#include<stdio.h>
#include<stdlib.h>
#include<Python.h>
staticPyObject*
wmf_reverse(PyObject*self,PyObject*args,PyObject*kwargs){
staticchar*kwlist[]={"name",NULL};
char*name=NULL;
PyObject*retval=NULL;
//問題1:只取一個字元串，format應該是"s"
//>>>if(PyArg_ParseTupleAndKeywords(args,keyds,"isi",kwlist,&name))
if(PyArg_ParseTupleAndKeywords(args,kwargs,"s",kwlist,&name)){
retval=(PyObject*)Py_BuildValue("i",1);
printf("%s ",name);
//問題2：不要釋放
//>>>free(name);
}else{
retval=(PyObject*)Py_BuildValue("i",0);
}
returnretval;
}
staticPyMethodDef
wmf_methods[]={
{"reverse",(PyCFunction)wmf_reverse,METH_VARARGS|METH_KEYWORDS,"reverse"},
//問題3：方法定義表，應該用一條空記錄來表示結束。
{NULL,NULL,0,NULL},
};
//問題4：沒有定義mole
staticstructPyMoleDef
wmf_mole={
PyMoleDef_HEAD_INIT,
"wmf",/*nameofmole*/
NULL,/*moledocumentation,maybeNULL*/
-1,/*sizeofper-interpreterstateofthemole,
or-.*/
wmf_methods,
};
//問題5：入口函數要聲明為：PyMODINIT_FUNC
PyMODINIT_FUNC
PyInit_wmf(void){
//問題6：Py_InitMole要初始化的是模塊，不是方法。所以傳方法定義是錯誤的。
//另外，python2.x是用Py_Init_mole，python3.x改用PyMole_Create了。
//兩者略有差別，自己注意一下吧。這里我用的是python3.x。
//Py_InitMole("wmf",ExtestMethods);
PyObject*m;
m=PyMole_Create(&wmf_mole);
if(m==NULL){
returnNULL;
}
returnm;
}
⑶ 怎樣讓Python腳本與C++程序互相調用
二、Python調用C/C++
1、Python調用C動態鏈接庫
Python調用C庫比較簡單，不經過任何封裝打包成so，再使用python的ctypes調用即可。
（1）C語言文件：pycall.c
[html] view plain
/***gcc -o libpycall.so -shared -fPIC pycall.c*/
#include <stdio.h>
#include <stdlib.h>
int foo(int a, int b)
{
printf("you input %d and %d\n", a, b);
return a+b;
}
（2）gcc編譯生成動態庫libpycall.so：gcc -o libpycall.so -shared -fPIC pycall.c。使用g++編譯生成C動態庫的代碼中的函數或者方法時，需要使用extern "C"來進行編譯。
（3）Python調用動態庫的文件：pycall.py
[html] view plain
import ctypes
ll = ctypes.cdll.LoadLibrary
lib = ll("./libpycall.so")
lib.foo(1, 3)
print '***finish***'
（4）運行結果：
2、Python調用C++(類)動態鏈接庫
需要extern "C"來輔助，也就是說還是只能調用C函數，不能直接調用方法，但是能解析C++方法。不是用extern "C"，構建後的動態鏈接庫沒有這些函數的符號表。
（1）C++類文件：pycallclass.cpp
[html] view plain
#include <iostream>
using namespace std;
class TestLib
{
public:
void display();
void display(int a);
};
void TestLib::display() {
cout<<"First display"<<endl;
}
void TestLib::display(int a) {
cout<<"Second display:"<<a<<endl;
}
extern "C" {
TestLib obj;
void display() {
obj.display();
}
void display_int() {
obj.display(2);
}
}
（2）g++編譯生成動態庫libpycall.so：g++ -o libpycallclass.so -shared -fPIC pycallclass.cpp。
（3）Python調用動態庫的文件：pycallclass.py
[html] view plain
import ctypes
so = ctypes.cdll.LoadLibrary
lib = so("./libpycallclass.so")
print 'display()'
lib.display()
print 'display(100)'
lib.display_int(100)
（4）運行結果：
3、Python調用C/C++可執行程序
（1）C/C++程序：main.cpp
[html] view plain
#include <iostream>
using namespace std;
int test()
{
int a = 10, b = 5;
return a+b;
}
int main()
{
cout<<"---begin---"<<endl;
int num = test();
cout<<"num="<<num<<endl;
cout<<"---end---"<<endl;
}
（2）編譯成二進制可執行文件：g++ -o testmain main.cpp。
（3）Python調用程序：main.py
[html] view plain
import commands
import os
main = "./testmain"
if os.path.exists(main):
rc, out = commands.getstatusoutput(main)
print 'rc = %d, \nout = %s' % (rc, out)
print '*'*10
f = os.popen(main)
data = f.readlines()
f.close()
print data
print '*'*10
os.system(main)
（4）運行結果：
4、擴展Python（C++為Python編寫擴展模塊）
所有能被整合或導入到其它python腳本的代碼，都可以被稱為擴展。可以用Python來寫擴展，也可以用C和C++之類的編譯型的語言來寫擴展。Python在設計之初就考慮到要讓模塊的導入機制足夠抽象。抽象到讓使用模塊的代碼無法了解到模塊的具體實現細節。Python的可擴展性具有的優點：方便為語言增加新功能、具有可定製性、代碼可以實現復用等。
為 Python 創建擴展需要三個主要的步驟：創建應用程序代碼、利用樣板來包裝代碼和編譯與測試。
（1）創建應用程序代碼
[html] view plain
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int fac(int n)
{
if (n < 2) return(1); /* 0! == 1! == 1 */
return (n)*fac(n-1); /* n! == n*(n-1)! */
}
char *reverse(char *s)
{
register char t, /* tmp */
*p = s, /* fwd */
*q = (s + (strlen(s) - 1)); /* bwd */
while (p < q) /* if p < q */
{
t = *p; /* swap & move ptrs */
*p++ = *q;
*q-- = t;
}
return(s);
}
int main()
{
char s[BUFSIZ];
printf("4! == %d\n", fac(4));
printf("8! == %d\n", fac(8));
printf("12! == %d\n", fac(12));
strcpy(s, "abcdef");
printf("reversing 'abcdef', we get '%s'\n", \
reverse(s));
strcpy(s, "madam");
printf("reversing 'madam', we get '%s'\n", \
reverse(s));
return 0;
}
上述代碼中有兩個函數，一個是遞歸求階乘的函數fac()；另一個reverse()函數實現了一個簡單的字元串反轉演算法，其主要目的是修改傳入的字元串，使其內容完全反轉，但不需要申請內存後反著復制的方法。
（2）用樣板來包裝代碼
介面的代碼被稱為「樣板」代碼，它是應用程序代碼與Python解釋器之間進行交互所必不可少的一部分。樣板主要分為4步：a、包含Python的頭文件；b、為每個模塊的每一個函數增加一個型如PyObject* Mole_func()的包裝函數；c、為每個模塊增加一個型如PyMethodDef MoleMethods[]的數組；d、增加模塊初始化函數void initMole()。
⑷ python 在類中如何讓方法之間互相調用
python 在類中方法之間互相調用的方法：
>>> class OP():
... def __init__(self,p):
... self.p=p
... def re(self):
... self.p+=1
... def s(self):
... self.re()
... print self.p
...
>>> vb=OP(2)
>>> vb.s
<bound method="" OP.s of <__main__.OP instance at 0x00E23300>>
>>> vb.s()
3
>>>
⑸ 多個python文件相互調用
假如a.py這個文件有一個函數fun，那麼在b.py這個文件就可以調用這個函數，只需要寫一行代碼即可：from a import fun
⑹ Python如何進行內存管理
Python是如何進行內存管理的？
答:從三個方面來說,一對象的引用計數機制,二垃圾回收機制,三內存池機制。
一、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。
引用計數增加的情況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減少的情況：
1，使用del語句對對象別名顯示的銷毀
2，引用超出作用域或被重新賦值
Sys.getrefcount( )函數可以獲得對象的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對於不可變數據（如數字和字元串），解釋器會在程序的不同部分共享內存，以便節約內存。
相關推薦：《Python視頻教程》
二、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，並銷毀用於引用底層對象的名稱。然而由於每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。（從而導致內存泄露）。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。
三、內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
⑺ python函數與函數之間值的相互調用
printlist()函數增加一個參數n，變成printlist(n)
調用函數時，將makelist()函數的結果作為printlist(n)函數的參數
printlist(makelist())
⑻ 請教編程高手一個python與C++相互調用的問題
python 我不懂，了解過，似乎是解釋型語言，不過有py2exe這東西，
如果你知道python的結構體在內存中的組織形式，那你把數據的內存組織形式告訴我，我可以給你封裝一個庫，這個庫提供C++介面接收你的結構體參數
如果你自己懂某一操作平台下的C++底層實現（懂匯編就ok），這問題分分鍾搞定
如果你懂python的底層實現，你根本不會遇到這種問題！！！！
⑼ python程序的問題，兩個平行子類的相互調用
這個Quitter和Demo是不是都繼承於Frame沒關系。這個就是簡單的建立一個Quitter的instance，讓Quitter的__init__的parent參數等於現在正在初始化的這個Demo的instance而已。
⑽ python中類內部的函數可以互相調用嗎
可以把變數設置為全局變數：def fun1(): global var1 ...def fun2(): global var1