python全局列表

㈠ python中 自己定義的函數內生成的列表 怎麼在外部中引用

下面的例子演示了用3種方法來在外部引用函數內部定義的列表：

#返回函數內部定義的列表

def int_list1():

l=[1,2]

return l

#將函數內部列表定義成全局的

def int_list2():

global l

l=[3,4]

#將函數內部列表定義成函數的一個屬性

def int_list3():

l=[5,6]

int_list3.l=l

print(int_list1())

int_list2()

print(l)

int_list3()

print(int_list3.l)

這是截圖：

㈡ 如何查看 Python 全部內置變數和內置函數

查看python內置函數的方法：1、打開Python IDLE編輯器；2、輸入" dir(__builtins__)"命令，按下回車鍵（Enter）得到Python全部內置變數和函數。

如何查看 Python 全部內置變數和內置函數？

1 如圖，打開 Python IDLE，我用的 是 Python 3.7 ，界面有個性定製。你的版本不同，界面有差異，但是操作方法應該是一樣的。

2 輸入 dir(__builtins__)

按下回車鍵（Enter）。

3 也可以：

import builtins

dir(builtins)

按下回車鍵（Enter）。

得到的結果和 dir(__builtins__) 是一樣的。

4 那麼這返回的一大堆到底是什麼東西？

可以看到，返回的結果是以 [ 開頭以 ] 結尾，說明是個列表，我們看看這列表裡一共有多少個元素？

輸入：

len(dir(__builtins__)）

得到一個數字，154 ，說明當前版本的 Python 內置的常量和函數總數是 154 。

5 我們再重新輸出一下這個列表，逐個列印出來，更好看一點。

for item in dir(__builtins__):

print(item)

按下兩次回車鍵（Enter）。按照默認的字母順序，先是大寫字母 A-Z，然後是下劃線（_）開頭的，然後是小寫字母 a-z ，為什麼是這個順序？因為按照 ASCII 碼表，表示小寫字母的數字比表示大寫字母的數字要大，而表示下劃線（_）的數字居中，所以如此。

6 print() 就是 Python 3 的默認函數。我們試試：

print('Hello World')

builtins.print('Hello World')

__builtins__.print('Hello World')

運行結果如下，可以看到，結果是一樣的。

dir()本身就是 Python 的內置函數，利用它，我們可以查看對象的全部方法和屬性，對於掌控全局，了解全貌很有用。

課程推薦：Python快速教程之從入門到精通

㈢ python 函數內聲明的數組是全局的嗎

不是全局的。如果你只是想在函數內弄一個全局變數，那麼global可以很好地解決問題，但是如果是數組的話，你可以這樣：先在函數外定義一個空列表（數組），然後再在函數內修改它，這樣就是全局的啦！

㈣ Python基本內置數據類型有哪些

內置類型是指任何語言在設計初期定義的類型，如C語言中的int、double、char等。它也是在一種語言中最基本的類型，與編譯器編譯出的代碼具有重大關系。值得一提的是，不同語言也擁有不同的內置類型， 但是所有內置類型的定義都與計算機的運算方式相關。
Python主要內置類型包括數值、序列、映射、類、實例和異常等。
數值類型：全局中只有一個（Python在解釋器啟動的時候，Python會用None類型生成一個None的對象），包括int類型、float類型、complex類型、bool類型。
迭代類型：在Python中，迭代類型可以使用循環來進行遍歷。
序列類型：list（是可變序列，通常用於存放同類項目的集合）、tuple（是不可變序列，通常用於儲存異構數據的多項集）、str（在Python中處理文本數據是使用str對象，也稱為字元串。字元串是由Unicode碼位構成的不可變序列。）、array、range（表示不可變的數字序列，通常用於在for循環中循環指定的次數）、bytes（由單個位元組構成的不可變序列）、bytearray（bytes對象的可變對應物）、memoryvie（二進制序列）
映射類型：映射對象將具有hash的值映射到任意對象。映射是可變的對象。目前只有一種標准映射，即dictionary。字典的鍵幾乎是任意值，也就是說，包含列表、字典或其他可變類型的值。
集合類型：作為一種無序的多項集，集合並不記錄元素位置或插入順序。相應地，集合不支持索引、切片或其他序列類的操作。目前Python有兩種內置集合類型：set和frozenset。
set類型是可變的，其內容可以使用add()和remove()這樣的方法來改變。由於是可變類型，它沒有哈希值，且不能被用作字典的鍵或其他集合的元素。
frozenset類型是不可變並且具有哈希值，其內容在被創建後不能再改變，因此它可以被用作字典的鍵或其他集合的元素。
上下文管理類型：with語句
其他類型：模塊、class、實例、函數、方法、代碼、object對象、type對象、ellipsis（省略號）、notimplemented

㈤ python中的列表是不是全局性的詳見描述

1、py列表在主程序區創建後似乎能在各個定義的函數中讀取,不知我說的是否正確?
答：是的，在函數外創建的變數是全局變數，在函數中是可以讀寫全局變數的。
2、還想請問一下,有沒有其他數據類型能全局使用?
答：變數是否全局並不是因為它的數據類型，而是要看它是在哪裡定義的，在函數外定義就是全局，函數內定義就是局部。
3、變數這種的是不是局部性,只能在當前函數或程序中使用?
函數內部定義的變數只能在函數內部調用。

㈥ python3.5類型參數列表問題，怎麼解決

剛開始學習python，python相對於java確實要簡潔易用得多。內存回收類似hotspot的可達性分析， 不可變對象也如同java得Integer類型，with函數類似新版本C++的特性，總體來說理解起來比較輕松。只是函數部分參數的"*"與"**"，閉包等問題，著實令人迷糊了一把，弄清概念後寫下此文記錄下來,也希望本文能夠幫助其他初學者。
所以本文是一篇學習筆記，著重於使用的細節和理解上，首先分別介紹了函數各種參數類型在調用和聲明時的區別，及其在混用時需要注意的一些細節，之後講了閉包相關的內容。如果有不對的地方歡迎指正。
函數參數不帶「*」，"*" 與 "**"的區別
理解這個問題得關鍵在於要分開理解調用和聲明語法中3者得區別.
函數調用區別
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

閉包
python的函數,原本只能訪問兩個區域的變數:全局,和局部(函數上下文). 實際上,函數本身也是一個對象,也有自己的作用域. 閉包通過函數與引用集合的組合,使得函數可以在它被定義的區域之外執行. 這個集合可以通過func_closure來獲取這個引用集合. 這與python處理全局變數得方式一樣,只不過全局變數將引用集合存儲在__globals__欄位中.func_closure是一個存儲cell類型的元組,每個cell存儲一個上下文變數.
另外,舊版本得python的內部函數不能在其他作用域使用的原因,並不是因為每個作用域的變數嚴格相互隔離,而是脫離原本的作用域後,函數失去了原本上下文的引用。需要注意的是，閉包存儲的上下文信息一樣是淺拷貝,所以傳遞給內部函數的可變對象仍然會被其他擁有該對象引用得變數修改.
舉個例子:

復制代碼代碼如下:

>>> 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

㈦ python 獲取global contact list

貼出完整源代碼。
代碼中：使用二維碼登錄網頁版微信，並下載好友頭像，並將好友資料數據存入csv文件，待進一步處理全局聯絡人列表也被導入在導入之後，某些列表被提供給用戶的地址簿，如果用戶已選擇了該選項的話全局聯絡人列表(GlobalContactList)是經由GUID標識的給定源用戶的聯絡人的有序列表。
Python是一種跨平台的計算機程序設計語言是一個高層次的結合了解釋性、編譯性、互動性和面向對象的腳本語言最初被設計用於編寫自動化腳本(shell)，隨著版本的不斷更新和語言新功能的添加，越多被用於獨立的、大型項目的開發Python的應用領域還是非常廣泛的，因為Python是一種解釋型腳本語言，所以可以應用的領域就非常的豐富，比如：Web和Internet開發，科學計算和統計，人工智慧，桌面界面開發，軟體開發，後端開發。

㈧ python 列表 全局

都有全局和局部之分；
你那個情況可能是把list當作全局變數了；

㈨ 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里 列表是不是不像全局變數，會在函數中被改變

我覺得是，列表是個一種數據結構，而100是個整數類型的數據，其值是存在在內存里，調用函數可以改變數據結構，但是改變不了內存里的值，你可以試下改變列表裡的值。