示例demo：

#!/usr/bin/env python

import os
import sys
import inspect
import logging

from datetime import *

def get_head_info():
     try:
         raise Exception
     except:
         f = sys.exc_info()[2].tb_frame.f_back
     return '%s, %s, %s, %s, ' % (str(datetime.now()), f.f_code.co_filename, f.f_code.co_name, str(f.f_lineno))

def call_func():
    print '%s --> skdkjzz' % (get_head_info())

def main():
    call_func();

if __name__ == '__main__':
     sys.exit(main())   

執行效果如下：

2014-12-26 09:57:23.464724, headinfo_py, call_func, 18,  --> skdkjzz

注：

1、import與from xxx import *區別

import
作用：
匯入/引入一個python標準模組，其中包括.py檔案、帶有__init__.py檔案的目錄。
e.g：

1. import module_name[,module1,...]  
2. from module import *|child[,child1,...]  

<span style="font-size:12px;">import module_name[,module1,...]
from module import *|child[,child1,...]</span>

說明：
多次重複使用import語句時，不會重新載入被指定的模組，只是把對該模組的記憶體地址給引用到本地變數環境。
測試：

1. a.py  
2. #!/usr/bin/env python  
3. #encoding: utf-8
4. import os  
5. print'in a',id(os)  
6. m.py  
7. #!/usr/bin/env python  
8. #encoding: utf-8
9. import a   #第一次會列印a裡面的語句
10. import os  #再次匯入os後，其記憶體地址和a裡面的是一樣的，因此這裡只是對os的本地引用
11. print'in c',id(os)  
12. import a  #第二次不會列印a裡面的語句，因為沒有重新載入

<span style="font-size:12px;">a.py
#!/usr/bin/env python  
#encoding: utf-8
import os
print 'in a',id(os)

m.py
#!/usr/bin/env python  
#encoding: utf-8
import a   #第一次會列印a裡面的語句
import os  #再次匯入os後，其記憶體地址和a裡面的是一樣的，因此這裡只是對os的本地引用
print 'in c',id(os)
import a  #第二次不會列印a裡面的語句，因為沒有重新載入</span>

reload
作用：
對已經載入的模組進行重新載入，一般用於原模組有變化等特殊情況，reload前該模組必須已經import過。
e.g：
import os
reload(os)
說明：
reload會重新載入已載入的模組，但原來已經使用的例項還是會使用舊的模組，而新生產的例項會使用新的模組；reload後還是用原來的記憶體地址；不能支援from。。import。。格式的模組進行重新載入。
測試：

1. a.py  
2. #!/usr/bin/env python  
3. #encoding: utf-8
4. import os  
5. print'in a',id(os)  
6. m.py  
7. #!/usr/bin/env python  
8. #encoding: utf-8
9. import a   #第一次import會列印a裡面的語句
10. print id(a) #原來a的記憶體地址
11. reload(a)  #第二次reload還會列印a裡面的語句，因為有重新載入
12. print id(a) #reload後a的記憶體地址，和原來一樣

<span style="font-size:12px;">a.py
#!/usr/bin/env python  
#encoding: utf-8
import os
print 'in a',id(os)

m.py
#!/usr/bin/env python  
#encoding: utf-8
import a   #第一次import會列印a裡面的語句
print id(a) #原來a的記憶體地址
reload(a)  #第二次reload還會列印a裡面的語句，因為有重新載入
print id(a) #reload後a的記憶體地址，和原來一樣</span>

擴充套件：
上面說了，在特殊情況的下才會使用reload函式；除了原來模組檔案有修改外，還有哪些情況需要使用reload函式呢，這裡舉個例子。

1. #!/usr/bin/env python  
2. #encoding: utf-8
3. import sys   #引用sys模組進來，並不是進行sys的第一次載入
4. reload(sys)  #重新載入sys
5. sys.setdefaultencoding('utf8')  ##呼叫setdefaultencoding函式

<span style="font-size:12px;">#!/usr/bin/env python  
#encoding: utf-8
import sys   #引用sys模組進來，並不是進行sys的第一次載入
reload(sys)  #重新載入sys
sys.setdefaultencoding('utf8')  ##呼叫setdefaultencoding函式</span>

上面的程式碼是正確的，再測試下面的程式碼

1. #!/usr/bin/env python  
2. #encoding: utf-8
3. import sys     
4. sys.setdefaultencoding('utf8')   

<span style="font-size:12px;">#!/usr/bin/env python  
#encoding: utf-8
import sys   
sys.setdefaultencoding('utf8') </span>

上面的測試會失敗，那麼為什麼要在呼叫setdefaultencoding時必須要先reload一次sys模組呢？因為這裡的import語句其實並不是sys的第一次匯入語句，也就是說這裡其實可能是第二、三次進行sys模組的import，這裡只是一個對sys的引用，只能reload才能進行重新載入；那麼為什麼要重新載入，而直接引用過來則不能呼叫該函式呢？因為setdefaultencoding函式在被系統呼叫後被刪除了，所以通過import引用進來時其實已經沒有了，所以必須reload一次sys模組，這樣setdefaultencoding才會為可用，才能在程式碼裡修改直譯器當前的字元編碼。試試下面的程式碼，同樣會報錯：

1. #!/usr/bin/env python  
2. #encoding: utf-8
3. import sys    
4. reload(sys)   
5. sys.setdefaultencoding('utf8')    
6. del sys.setdefaultencoding   ##刪除原來的setdefaultencoding函式   
7. sys.setdefaultencoding('gb2312') 

   <span style="font-size:12px;">#!/usr/bin/env python  
   #encoding: utf-8
   import sys  
   reload(sys) 
   sys.setdefaultencoding('utf8')  
   del sys.setdefaultencoding   ##刪除原來的setdefaultencoding函式   
   sys.setdefaultencoding('gb2312')</span>

那麼到底是誰在之前就匯入sys並且呼叫了setdefaultencoding函式呢？答案就在python安裝目錄的Lib資料夾下，有一個叫site.py的檔案【python2.6】，在裡面可以找到main() --> setencoding()-->sys.setdefaultencoding(encoding),因為這個site.py每次啟動python直譯器時會自動載入，所以main函式每次都會被執行，setdefaultencoding函式一出來就已經被刪除了。

__import__
作用：
同import語句同樣的功能，但__import__是一個函式，並且只接收字串作為引數，所以它的作用就可想而知了。其實import語句就是呼叫這個函式進行匯入工作的，import sys <==>sys = __import__('sys')
e.g：

__import__(module_name[, globals[, locals[, fromlist]]]) #可選引數預設為globals(),locals(),[]
__import__('os')    
__import__('os',globals(),locals(),['path','pip'])  #等價於from os import path, pip

說明：

通常在動態載入時可以使用到這個函式，比如你希望載入某個資料夾下的所用模組，但是其下的模組名稱又會經常變化時，就可以使用這個函式動態載入所有模組了，最常見的場景就是外掛功能的支援。

擴充套件：
既然可以通過字串來動態匯入模組，那麼是否可以通過字串動態重新載入模組嗎？試試reload('os')直接報錯，是不是沒有其他方式呢?雖然不能直接reload但是可以先unimport一個模組，然後再__import__來重新載入模組。現在看看unimport操作如何實現，在python解釋裡可以通過globals(),locals(),vars(),dir()等函式檢視到當前環境下載入的模組及其位置，但是這些都只能看不能刪除，所以無法unimport；不過除此之外還有一個地方是專門存放模組的，這就是sys.modules，通過sys.modules可以檢視所有的已載入並且成功的模組，而且比globals要多，說明預設會載入一些額外的模組，接下來就是unimport了。

1. #!/usr/bin/env python  
2. #encoding: utf-8
3. import sys  
4. __import__('a')      #第一次匯入會列印訊息
5. del sys.modules['a']   #unimport
6. __import__('a')    #再次匯入還是會列印訊息，因為已經unimport一次了
7. __import__('a')    #這次就不會列印訊息了

最近在用codecademy學python，遇到一些題目錯誤，小小記錄一下

如from math import sqrt是把sqrt作為本檔案的方法匯入進來了，使用的時候只需要直接呼叫sqrt。

而如果import是import math，那麼呼叫的時候要採用math.sqrt的方式。

那麼如果在自己的檔案裡定義了相同名字的函式怎麼辦呢，來實驗一下

執行py檔案輸出13689，所以自己定義了函式會自動遮蔽掉。

所以大量引用import math.*是個比較好的辦法，from math import *就容易出錯了，當然用到很少的函式且次數較多時上面這種辦法會比較合適。

另外python不支援像java那樣import math.sqrt