python全局符號表

❶ 程序開發中定義函數的使用方法是什麼

第一：定義函數
1.1 我們可以創建一個用來生成指定邊界的斐波那契數列的函數:
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
1.2 關鍵字 def 引入了一個函數 定義。在其後必須跟有函數名和包括形式參數的圓括弧。函數體語句從下一行開始，必須是縮進的。
1.3 函數體的第一行語句可以是可選的字元串文本，這個字元串是函數的文檔字元串，或者稱為 docstring。（更多關於 docstrings 的信息請參考 文檔字元串） 有些工具通過 docstrings 自動生成在線的或可列印的文檔，或者讓用戶通過代碼交互瀏覽；在你的代碼中包含 docstrings 是一個好的實踐，讓它成為習慣吧。
1.4 函數 調用 會為函數局部變數生成一個新的符號表。確切的說，所有函數中的變數賦值都是將值存儲在局部符號表。變數引用首先在局部符號表中查找，然後是包含函數的局部符號表，然後是全局符號表，最後是內置名字表。因此，全局變數不能在函數中直接賦值（除非用 global 語句命名），盡管他們可以被引用。
1.5 函數引用的實際參數在函數調用時引入局部符號表，因此，實參總是 傳值調用 （這里的 值 總是一個對象 引用 ，而不是該對象的值）。[1] 一個函數被另一個函數調用時，一個新的局部符號表在調用過程中被創建。
1.6 一個函數定義會在當前符號表內引入函數名。函數名指代的值（即函數體）有一個被 python 解釋器認定為 用戶自定義函數 的類型。 這個值可以賦予其他的名字（即變數名），然後它也可以被當作函數使用。這可以作為通用的重命名機制:
>>> fib
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
1.7 如果你使用過其他語言，你可能會反對說：fib 不是一個函數，而是一個方法，因為它並不返回任何值。事實上，沒有 return 語句的函數確實會返回一個值，雖然是一個相當令人厭煩的值（指 None ）。這個值被稱為 None （這是一個內建名稱）。如果 None 值是唯一被書寫的值，那麼在寫的時候通常會被解釋器忽略（即不輸出任何內容）。如果你確實想看到這個值的輸出內容，請使用 print() 函數:

❷ python 全局變數怎麼用

在python中，全局變數一般有兩種使用方式：
第一種：是在一個單獨的模塊中定義好，然後在需要使用的全局模塊中將定義的全局變數模塊導入。
第二種：直接在當前的模塊中定義好，然後直接在本模塊中通過global聲明，然後使用具體的方法如下所示：
第一種：
復制代碼
SOLR_URL='http://solr.org'
def tt():
global SOLR_URL
SOLR_URL=SOLR_URL+'#aa'
if __name__=='__main__':
tt()
print SOLR_URL
#輸出：
http://solr.org#aa
復制代碼
PS：在此種用法中，如果我們在函數tt中不使用global 聲明全局變數SOLR_URL,其實也可以使用，但是此時應該是作為一個內部變數使用，由於沒有初始值，因此報錯Python查找變數是順序是：先局部變數，再全局變數復制代碼
SOLR_URL='http://solr.org'
def tt():
#global SOLR_URL
SOLR_URL=SOLR_URL+'#aa'
if __name__=='__main__':
tt()
print SOLR_URL
#輸出：
SOLR_URL=SOLR_URL+'#aa'
UnboundLocalError: local variable 'SOLR_URL' referenced before assignment復制代碼
第二種：
global_list.py
GLOBAL_A='hello'
GLOBAL_B='world'
test.py
復制代碼
import global_list
def tt():
print global_list.GLOBAL_A
if __name__=='__main__':
tt()
#輸出：
hello

❸ Python中定義函數的使用方法

4.6. 定義函數
我們可以創建一個用來生成指定邊界的斐波那契數列的函數:
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
關鍵字 def 引入了一個函數 定義。在其後必須跟有函數名和包括形式參數的圓括弧。函數體語句從下一行開始，必須是縮進的。
函數體的第一行語句可以是可選的字元串文本，這個字元串是函數的文檔字元串，或者稱為 docstring。（更多關於 docstrings 的信息請參考 文檔字元串） 有些工具通過 docstrings 自動生成在線的或可列印的文檔，或者讓用戶通過代碼交互瀏覽；在你的代碼中包含 docstrings 是一個好的實踐，讓它成為習慣吧。
函數 調用 會為函數局部變數生成一個新的符號表。確切的說，所有函數中的變數賦值都是將值存儲在局部符號表。變數引用首先在局部符號表中查找，然後是包含函數的局部符號表，然後是全局符號表，最後是內置名字表。因此，全局變數不能在函數中直接賦值（除非用 global 語句命名），盡管他們可以被引用。
函數引用的實際參數在函數調用時引入局部符號表，因此，實參總是 傳值調用 （這里的 值 總是一個對象 引用 ，而不是該對象的值）。[1] 一個函數被另一個函數調用時，一個新的局部符號表在調用過程中被創建。
一個函數定義會在當前符號表內引入函數名。函數名指代的值（即函數體）有一個被 Python 解釋器認定為 用戶自定義函數 的類型。 這個值可以賦予其他的名字（即變數名），然後它也可以被當作函數使用。這可以作為通用的重命名機制:
>>> fib
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
如果你使用過其他語言，你可能會反對說：fib 不是一個函數，而是一個方法，因為它並不返回任何值。事實上，沒有 return 語句的函數確實會返回一個值，雖然是一個相當令人厭煩的值（指 None ）。這個值被稱為 None （這是一個內建名稱）。如果 None 值是唯一被書寫的值，那麼在寫的時候通常會被解釋器忽略（即不輸出任何內容）。如果你確實想看到這個值的輸出內容，請使用 print() 函數:

❹ 那些Python中的模塊

Python的解釋環境是很好用，但是如果我們需要編寫一個大型的程序的時候，解釋環境就完全不夠用了。這個時候我們需要將python程序保存在一個文件里。通常這個文件是以.py結尾的。

對於大型的應用程序來說，一個文件可能是不夠的，這個時候我們需要在文件中引用其他的文件，這樣文件就叫做模塊。

模塊是一個包含Python定義和語句的文件。文件名就是模塊名後跟文件後綴 .py 。在模塊內部，模塊名可以通過全局變數 __name__ 獲得。

還是之前的斐波拉赫數列的例子，我們在fibo.py文件中存放了函數的實現：

編寫完畢之後，我們可以在Python的解釋環境中導入它：

然後直接使用即可：

常用的函數，我們可以將其賦值給一個變數：

或者，我們在導入的時候，直接給這個模塊起個名字：

或者導入模塊中的函數：

每個模塊都有它自己的私有符號表，該表用作模塊中定義的所有函數的全局符號表。因此，模塊的作者可以在模塊內使用全局變數，而不必擔心與用戶的全局變數發生意外沖突。

前面我們提到了可以使用import來導入一個模塊，並且 __name__ 中保存的是模塊的名字。

和java中的main方法一樣，如果我們想要在模塊中進行一些測試工作，有沒有類似java中main方法的寫法呢？

先看一個例子：

在模塊中，我們需要進行一個判斷 __name__ 是不是被賦值為 "__main__"。

我們這樣來執行這個模塊：

以腳本執行的情況下，模塊的 __name__ 屬性會被賦值為 __main__ , 這也是例子中為什麼要這樣寫的原因。

看下執行效果：

如果是以模塊導入的話，那麼將不會被執行：

使用import導入模塊的時候，解釋器首先會去找該名字的內置模塊，如果沒找到的話，解釋器會從 sys.path變數給出的目錄列表裡尋找。

sys.path的初始目錄包括：

要想查看模塊中定義的內容，可以使用dir函數。

上面的例子列出了當前模塊中定義的內容，包括變數，模塊，函數等。

我們可以給dir加上參數，來獲取特定模塊的內容：

java中有package的概念，用來隔離程序代碼。同樣的在Python中也有包。

我們看一個Python中包的例子：

上面我們定義了4個包，分別是sound,sound.formats, sound.effects, sound.filters。

__init__.py 可以是一個空文件，也可以執行包的初始化代碼或設置 __all__ 變數。

當導入的時候， python就會在 sys.path 路徑中搜索該包。

包的導入有很多種方式，我們可以導入單個模塊：

但是這樣導入之後，使用的時候必須載入全名：

如果不想載入全名，可以這樣導入：

那麼就可以這樣使用了：

還可以直接導入模塊中的方法：

然後這樣使用：

如果一個包裡面的子包比較多，我們可能會希望使用 * 來一次性導入：

那麼如何去控制到底會導入effects的哪一個子包呢？

我們可以在 __init__.py 中定義一個名叫 __all__ 的列表，在這個列表中列出將要導出的子包名，如下所示：

這樣from sound.effects import * 將導入 sound 包的三個命名子模塊。

如果沒有定義 __all__，from sound.effects import * 語句 不會 從包 sound.effects 中導入所有子模塊到當前命名空間；它只會導入包 sound.effects。

Import 可以指定相對路徑，我們使用 . 來表示當前包， 使用 .. 來表示父包。

如下所示：

❺ Python里怎麼查看某個函數的本地符號表

這得看你的二進製程序是否包含這些信息。這得看 編譯選項 有沒有包含 -s 。-s選項會剔除不需要的符號名。 正式二進制發布的軟體是可以沒有這些信息的。

❻ Python怎麼深入模塊進行學習

6.1. 深入模塊
除了包含函數定義外，模塊也可以包含可執行語句。這些語句一般用來初始化模塊。他們僅在 第一次 被導入的地方執行一次。[1]
每個模塊都有自己私有的符號表，被模塊內所有的函數定義作為全局符號表使用。因此，模塊的作者可以在模塊內部使用全局變數，而無需擔心它與某個用戶的全局變數意外沖突。從另一個方面講，如果你確切的知道自己在做什麼，你可以使用引用模塊函數的表示法訪問模塊的全局變數，modname.itemname。
模塊可以導入其他的模塊。一個（好的）習慣是將所有的 import 語句放在模塊的開始（或者是腳本），這並非強制。被導入的模塊名會放入當前模塊的全局符號表中。
import 語句的一個變體直接從被導入的模塊中導入命名到本模塊的語義表中。例如:
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
這樣不會從局域語義表中導入模塊名（如上所示， fibo 沒有定義）。
甚至有種方式可以導入模塊中的所有定義:
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
這樣可以導入所有除了以下劃線( _ )開頭的命名。
需要注意的是在實踐中往往不鼓勵從一個模塊或包中使用 * 導入所有，因為這樣會讓代碼變得很難讀。不過，在互動式會話中這樣用很方便省力。

❼ 求助一個關於python3.4的相對包導入問題，很初級

關於 from .. import 是如下說明的：

From…import 語句

Python的from語句讓你從模塊中導入一個指定的部分到當前命名空間中。語法如下：
from modname import name1[, name2[, ... nameN]]

例如，要導入模塊fib的fibonacci函數，使用如下語句：
from fib import fibonacci

這個聲明不會把整個fib模塊導入到當前的命名空間中，它只會將fib里的fibonacci單個引入到執行這個聲明的模塊的全局符號表。

From…import* 語句

把一個模塊的所有內容全都導入到當前的命名空間也是可行的，只需使用如下聲明：
from modname import *

這提供了一個簡單的方法來導入一個模塊中的所有項目。然而這種聲明不該被過多地使用。

所以感覺你應當是用from b import * 和 from a import * 或者直接 import a,b

❽ python中怎麼定義全局變數

復制代碼
count = 0
def Fuc(count):
print count
count += 1

for i in range(0, 10):
Fuc(count)
復制代碼
結果是：
不是我們想要的結果。
解決之道一——全局變數：
復制代碼
global a
a = 3

def Fuc():
global a
print a
a = a + 1
if __name__ == "__main__":
global a
for i in range(10):
Fuc()print 'hello'
print a
復制代碼
結果：

注意要領：
哪裡需要全局變數，哪裡聲明一下；但是函數千萬不要傳參數， Fuc(a)是不行的。
解決之道二——列表：
復制代碼
a = [3]

def Fuc():
print a[0]
a[0] = a[0] + 1
if __name__ == "__main__":
global a
for i in range(10):
Fuc()
print 'hello'
print a[0]
復制代碼
結果同上
列表可以比肩簡單的實現，學習之。

❾ 求Python中全局變數的詳細理解

題主你好,

拿實際例子和你說一下吧, 更好理解一些.

我們在拿到一個python腳本的時候,往往發現裡面都有如下語句:

=====

希望可以幫到題主, 歡迎追問.

❿ 在python中,如果出現局部變數和全局變數同名,則服從什麼原則

局部優先
所有函數中的變數賦值都是將值存儲在局部符號表。變數引用首先在局部符號表中查找，然後是包含函數的局部符號表，然後是全局符號表，最後是內置名字表。