python嵌套列表報錯

A. python如下報錯是什麼意思

要把代碼發現來才知道，以下是常見的錯誤
下面終於要講到當你用到更多的Python的功能（數據類型，函數，模塊，類等等）時可能碰到的問題了。由於篇幅有限，這里盡量精簡，尤其是對一些高級的概念。要想了解更多的細節，敬請閱讀Learning Python, 2nd Edition的「小貼士」以及「Gotchas」章節。

打開文件的調用不使用模塊搜索路徑
當你在Python中調用open()來訪問一個外部的文件時，Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑，或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。
不同的類型對應的方法也不同
列表的方法是不能用在字元串上的，反之亦然。通常情況下，方法的調用是和數據類型有關的，但是內部函數通常在很多類型上都可以使用。舉個例子來說，列表的reverse方法僅僅對列表有用，但是len函數對任何具有長度的對象都適用
不能直接改變不可變數據類型
記住你沒法直接的改變一個不可變的對象（例如，元組，字元串）：

T = (1, 2, 3)
T[2] = 4 # 錯誤

用切片，聯接等構建一個新的對象，並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存，因此這沒有看起來那麼浪費：

T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4)

使用簡單的for循環而不是while或者range
當你要從左到右遍歷一個有序的對象的所有元素時，用簡單的for循環（例如，for x in seq:）相比於基於while-或者range-的計數循環而言會更容易寫，通常運行起來也更快。除非你一定需要，盡量避免在一個for循環里使用range：讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題，但是第一個通常來說更好；在Python里，簡單至上。

S = "lumberjack"

for c in S: print c # 最簡單

for i in range(len(S)): print S[i] # 太多了

i = 0 # 太多了
while i < len(S): print S[i]; i += 1

不要試圖從那些會改變對象的函數得到結果
諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象，但不會將它們改變的對象返回出來（它們會返回None）；正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼：

mylist = mylist.append(X)

目的是要得到append的結果，但是事實上這樣做會將None賦值給mylist，而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素，請看下面的例子：

D = {...}
for k in D.keys().sort(): print D[k]

差一點兒就成功了——keys方法會創建一個keys的列表，然後用sort方法來將這個列表排序——但是因為sort方法會返回None，這個循環會失敗，因為它實際上是要遍歷None（這可不是一個序列）。要改正這段代碼，將方法的調用分離出來，放在不同的語句中，如下：

Ks = D.keys()
Ks.sort()
for k in Ks: print D[k]

只有在數字類型中才存在類型轉換
在Python中，一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型，然後用浮點運算。但是下面的代碼就會出錯了：

S = "42"
I = 1
X = S + I # 類型錯誤

這同樣也是有意而為的，因為這是不明確的：究竟是將字元串轉換為數字（進行相加）呢，還是將數字轉換為字元串（進行聯接）呢？在Python中，我們認為「明確比含糊好」（即，EIBTI（Explicit is better than implicit）），因此你得手動轉換類型：

X = int(S) + I # 做加法: 43
X = S + str(I) # 字元串聯接: "421"

循環的數據結構會導致循環
盡管這在實際情況中很少見，但是如果一個對象的集合包含了到它自己的引用，這被稱為循環對象（cyclic object）。如果在一個對象中發現一個循環，Python會輸出一個[…]，以避免在無限循環中卡住：

>>> L = ['grail'] # 在 L中又引用L自身會
>>> L.append(L) # 在對象中創造一個循環
>>> L
['grail', [...]]

除了知道這三個點在對象中表示循環以外，這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話，維護一個列表或者字典來表示已經訪問過的對象，然後通過檢查它來確認你是否碰到了循環。
賦值語句不會創建對象的副本，僅僅創建引用
這是Python的一個核心理念，有時候當行為不對時會帶來錯誤。在下面的例子中，一個列表對象被賦給了名為L的變數，然後L又在列表M中被引用。內部改變L的話，同時也會改變M所引用的對象，因為它們倆都指向同一個對象。

>>> L = [1, 2, 3] # 共用的列表對象
>>> M = ['X', L, 'Y'] # 嵌入一個到L的引用
>>> M
['X', [1, 2, 3], 'Y']

>>> L[1] = 0 # 也改變了M
>>> M
['X', [1, 0, 3], 'Y']

通常情況下只有在稍大一點的程序里這就顯得很重要了，而且這些共用的引用通常確實是你需要的。如果不是的話，你可以明確的給他們創建一個副本來避免共用的引用；對於列表來說，你可以通過使用一個空列表的切片來創建一個頂層的副本：

>>> L = [1, 2, 3]
>>> M = ['X', L[:], 'Y'] # 嵌入一個L的副本

>>> L[1] = 0 # 僅僅改變了L，但是不影響M
>>> L
[1, 0, 3]
>>> M
['X', [1, 2, 3], 'Y']

切片的范圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了，那麼切片會抽取該序列中的所有元素，並創造一個頂層的副本（一個新的，不被公用的對象）。對於字典來說，使用字典的dict.()方法。
靜態識別本地域的變數名
Python默認將一個函數中賦值的變數名視作是本地域的，它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講，Python是在編譯def代碼時，去靜態的識別本地變數，而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話，會引起人們的誤解。比如，看看下面的例子，當你在一個引用之後給一個變數賦值會怎麼樣：

>>> X = 99
>>> def func():
... print X # 這個時候還不存在
... X = 88 # 在整個def中將X視作本地變數
...
>>> func( ) # 出錯了！

你會得到一個「未定義變數名」的錯誤，但是其原因是很微妙的。當編譯這則代碼時，Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時，執行print語句的時候，賦值語句還沒有發生，這樣Python便會報告一個「未定義變數名」的錯誤。
事實上，之前的這個例子想要做的事情是很模糊的：你是想要先輸出那個全局的X，然後創建一個本地的X呢，還是說這是個程序的錯誤？如果你真的是想要輸出這個全局的X，你需要將它在一個全局語句中聲明它，或者通過包絡模塊的名字來引用它。
默認參數和可變對象
在執行def語句時，默認參數的值只被解析並保存一次，而不是每次在調用函數的時候。這通常是你想要的那樣，但是因為默認值需要在每次調用時都保持同樣對象，你在試圖改變可變的默認值（mutable defaults）的時候可要小心了。例如，下面的函數中使用一個空的列表作為默認值，然後在之後每一次函數調用的時候改變它的值：

>>> def saver(x=[]): # 保存一個列表對象
... x.append(1) # 並每次調用的時候
... print x # 改變它的值
...
>>> saver([2]) # 未使用默認值
[2, 1]
>>> saver() # 使用默認值
[1]
>>> saver() # 每次調用都會增加！
[1, 1]
>>> saver()
[1, 1, 1]

有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態，它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是，當你第一次碰到它時會覺得這很奇怪，並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態（比如說類）。
要擺脫這樣的行為，在函數開始的地方用切片或者方法來創建默認參數的副本，或者將默認值的表達式移到函數裡面；只要每次函數調用時這些值在函數里，就會每次都得到一個新的對象：

>>> def saver(x=None):

... if x is None: x = [] # 沒有傳入參數？
... x.append(1) # 改變新的列表
... print x
...
>>> saver([2]) # 沒有使用默認值
[2, 1]
>>> saver() # 這次不會變了
[1]
>>> saver()
[1]

其他常見的編程陷阱
下面列舉了其他的一些在這里沒法詳述的陷阱：
在頂層文件中語句的順序是有講究的：因為運行或者載入一個文件會從上到下運行它的語句，所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。
reload不影響用from載入的名字：reload最好和import語句一起使用。如果你使用from語句，記得在reload之後重新運行一遍from，否則你仍然使用之前老的名字。
在多重繼承中混合的順序是有講究的：這是因為對superclass的搜索是從左到右的，在類定義的頭部，在多重superclass中如果出現重復的名字，則以最左邊的類名為准。
在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤，即便是真正的程序錯誤，和sys.exit()調用，也會被捕捉到。

B. 關於python列表嵌套問題

代碼如下：

student = [["001","張三","男"],["002","李四","男"],["003","王五","女"]]

text = input("性別：")

count = 0

for i in student:

if text == i[2]:

count+=1

print("性別{0}共有{1}人".format(text,count))

C. 關於Python 嵌套列表 def popular(graph_list,n) n是一個非負整數

clayton_list = [ [1,2,3], [0,3], [0,4], [0,1], [2] ]

def Calling_popular(graph_list,n):
people = []
result = {}
all = []
for i in graph_list:
for j in i:
people.append(j)
people = set(people)

for z in people:
result[z] = 0

for a in graph_list:
for b in people:
if b in a:
result[b] += 1
for d in people:
if result[d] >= n:
all.append(d)
return all

a = Calling_popular(clayton_list, 2)

print(a)

a = Calling_popular(clayton_list, 3)

print(a)

a = Calling_popular(clayton_list, 0)

print(a)
輸出
[0, 1, 2, 3]
[0]
[0, 1, 2, 3, 4]
變數野枝伍沒有用心去定義，要是你真的想學應該可以看的頌或懂，可以問搭含我

D. python 讀取文件轉為嵌套列表，這題應該如何解

file = open('a.txt'碰弊)
txt = file.read()
print txt
txt = txt.splitlines()
print txt
for i in xrange(len(txt)):
print i,txt[i]
txt[i] = txt[i].split(' '臘吵裂輪閉)
print txt[i],'\n'
output = txt
print output

E. 用Python實現合並兩個排序的列表，但一直報錯，請問怎麼修改啊

你所定義的listnodeclass和python自帶的listtype是不同的東西，不能通用，必須先轉換

其他小錯我直接幫你改掉了

下面是改好可以運行的代碼：

classListNode(object):
def__init__(self,val):
self.val=val
self.next=None
def__repr__(self):
returnstr(self.val)

defLinkedList(pythonlist):
l=ListNode(pythonlist[0])
c=l
foriinrange(1,len(pythonlist)):
l.next=ListNode(pythonlist[i])
l=l.next
returnc

defPythonList(ListNode):
l=[]
whileListNode!=None:
l.append(ListNode.val)
ListNode=ListNode.next
returnl

classSolution(object):
defmergeTwoLists(self,l1,l2):
ifl1isNone:
returnl2
ifl2isNone:
returnl1

mmyhead=ListNode(0)
mmyhead.next=None
p=mmyhead
:
ifl1.val<l2.val:
p.next=l1
l1=l1.next
else:
p.next=l2
l2=l2.next
p=p.next
ifl1isnotNone:
p.next=l1
else:
p.next=l2
returnmmyhead.next

l1=LinkedList([1,3,5,7])
l2=LinkedList([2,4,6,8])
sol=Solution()
print(PythonList(sol.mergeTwoLists(l1,l2)))

（LinkedList(pythonlist)方法把一個傳統的pythonlist轉換成你用的首位相銜的listnode形式，PythonList(ListNode)則是轉換回來）

同時，linkedlist的數據類型在c裡面比較常用，python裡面一般用不著這么麻煩

希望對你有幫助

F. Python list 生成式(推導式list comprehension)中嵌套if else

如果按中文習慣寫嵌套列表生成式可能寫出如下的錯誤語法

Python的語法是按英文閱讀方式設計的，因此，正常的方式應該是

或者用更簡潔的形式 [false,true][condition] is the syntax ：

通過示例學習Python列表推導
if/else in Python's list comprehension?
python one-line list comprehension: if-else variants
if else in a list comprehension [plicate]

G. 一個python中嵌套列表的問題，下圖中的兩種寫法，結果不一樣，這是為什麼

題主你好,
我說下我的理解, 這個要從內存分配上去看了.

[0]* 3 得到的結果是: [0,0,0], 這裡面3個0是被分配的不同內存地址,而
[[0]] * 3,得到的結果是: [[0],[0],[0]],這裡面3個[0]在內存中指的其實是一個地址,你可以將後兩個[0]理解為第1個[0]的兩個別名.
換個說法: [0]* 3 得到的結果[0,0,0]你將裡面的3個0理解為: 張三,李四,王五,這是3個人, 你改其中的一個對另兩個人是沒有影響的. 而
[[0]]*3 得到的結果[[0],[0],[0]]你可以理解為:張三,小張,阿三,其中小張和阿三是張三的兩個小名, 這三個[0]其實是1個人, 所以你改變其中一個[0],另外的兩個[0]肯定也會跟著變.
而你直接寫[[0],[0],[0]],可以理解為這三個[0]是三個不同的人.
至於為什麼[[0]]*3得到的是[[0],[0],[0]], 而直接定義[[0],[0],[0]]看著是一樣, 但當修改元素值的時候,得到的結果卻不同,這就是python的實現機制了,不用太糾結這個,因為python就是這樣設計的,你只需要明白這個邏輯,用的時候會用就好.
寫在最後: 這只是我自己的理解, 沒有理論依據,希望不會誤導題主.
希望可以幫到題主, 歡迎追問.

H. python 按列讀取文本數據 列表越界咋回事啊@_@ IndexError：list index out of range

因為空行導致split函數返回的tmp為空，所以tmp[0]導致了數組越界。

分析思答瞎路：

1、報錯信息裡面已經提示了第12有誤。

2、提示為數組index越界，而12行的代碼中tmp[0]涉及數組。

3、找到tmp的定義，是split函數分解之後的內容，應當為一個list列表。

4、但是此處連tmp[0]都提示梁舉兄有錯，說明tmp中沒有任何元素。

5、推得for i in f0,中的沒一行的數據i有問題，當運行到最後，回出現一個由問題的i。

所以文件最後一行為空行，通常為寫入文件函數每行之後附帶的 轉義字元導致。

(8)python嵌套列表報錯擴展閱讀：

IndexError: list index out of range錯誤的其他情況

第一種情況：

list[index]index超出范圍

第二種情況：

list是一個空的，沒有一個元素

進行list[0]就會報該錯誤。

一般外部輸入的數據都可能存在問題，所以通常在readlines或者read後要做一次處理。

這樣就避免了空橡襲行，欄位數不足，以及類型轉換出錯。

解決方案：

針對第一種情況，通過調試檢查代碼。

關於第二種情況，有兩種方法：

第一種：檢查讀入的數據是都有問題，比如讀入的txt文件是否存在空行等等，第二種解決方案，在代碼上改錯。

with open("linux_Yue_01.txt","r") as testFile:

testfileList = []

for v testFile.read().split(" ")

if not v.strip(): #字元串去掉空格不為空

continue

testfileList.extend([splitFileNameAndLabel(v)])

注意：[splitFileNameAndLabel(v)]是又方括弧的，否則不能成為列表中嵌套列表了。

I. 請教python列表嵌套問題

可以這樣寫：

l=[{'name':'張三','性別':'男','年齡':12,'成績':60},{'name':'張三','性別':'女','年齡':12,'成績':80},{'name':'李四','性別':'男','年齡':13,'成績':75},{'name':'王五','性別':'男','年齡':12,'成績':20}]

l=list(filter(lambda d:d['name']=='張三',l))

print(l)

這是運行截圖：