python函數中傳入list為啥會這樣,這破問題卡了一整天

代碼及運行結果如圖：

從你的問題來看是一個新手，建議直接放棄2.x版本學習3.x版本。對現在的你來說用到的2與3版本之間的差異可能也就是print(如圖中所示與你代碼的差異)，影響很小。

代碼解釋：

你的代碼中用A,B= inputlist,inputlist進行賦值，實際A與B都是指向了同一個內存對象，所以對其中任意一個做出修改，即修改了內存中的這個對象，造成A與B同時修改。解決方法，引入copy模塊中的deepcopy()函數，保證A與B指向長的一樣但在內存中是兩個對象，這樣對其中一個修改時完全不影響到另一個。

Python如下報錯是什么意思

要把代碼發現來才知道，以下是常見的錯誤

打開文件的調用不使用模塊搜索路徑

當你在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.copy()方法。

靜態識別本地域的變量名

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()調用，也會被捕捉到。

列表,元組,字符串是python的什么序列

序列

序列是Python中最基本的數據結構，包括字符串、列表、元組。

序列，顧名思義，是有序的，序列都有索引，都能進行索引、切片(截取)、加(連接)、乘(倍增)、檢查成員的操作。

因為序列有序，可通過位置來區分元素，所以序列中可含有相同的元素。

序列的通用操作

1、索引

seq[index] index從0開始，支持負數，-1表示最后一個元素。

2、切片(截取)

seq[start:end]可截取子序列，返回的是副本，原序列不變。缺省時默認start為0，end為-1。

3、+(連接)

seq1+seq2+seq3+.....將多個序列連接為一個序列，返回的是副本，原序列不變

序列的類型要相同，才能相加，比如列表只能+列表，不能+字符串。

4、*(倍增)

seq*n將序列擴展為原來的n倍，比如“hello”*2就是“hellohello”。返回的是副本，原序列不變。

5、in、not in(檢查成員)

element in/not in seq判斷某個成員是否在序列中，返回值是bool型

6、python內置函數，不必導入模塊：

len(seq)返回序列長度(元素個數)

max(seq)返回序列中值最大的元素

min(seq)返回序列中值最小的元素

列表(List)

列表中的元素類型可以不同，甚至可以嵌套復雜的數據類型。列表用中括號[ ]表示。

list1=[1,2,3]#類型相同

list2=[1,"ok",[1,2,3]]#類型不同&&嵌套

列表的常用方法

函數

描述

list.append(ele)

在list末尾添加一個元素

list.insert(index,ele)

在指定位置插入一個元素

list.count(ele)

統計list中ele出現的次數

list.extend(x)

擴展list，x可以是列表、元組、集合、字典(只添加key)。添加到list的末尾。

+連接只能連接相同類型的序列。

list.index(ele)

索引元素，返回索引

list.pop([index])

彈出(刪除)并返回指定位置上的元素，，缺省index時默認為-1(最后一個元素)。

list.remove(ele)

移除指定元素，若list中有多個ele，只移除第一個ele

list.copy()

復制list，返回復制的列表。示例：list2=list1.copy()

list.clear()

清空列表

list.reverse()

反序排列

list.sort(reverse=True)

將列表中的元素按升/降序排列，缺省參數時默認為False(升序)，True是降序。示例：

list.sort()#升序排列

list.sort(reverse=True)#降序排列

注意：此函數不返回排序后的列表。

列表(List)是可變的，如果上述方法修改了List，List會改變。

數字(Number)、字符串(String)、元組(Tuple)是不可變的，操作時返回的往往是副本，原來的值不變。

元組(Tuple)

元組中可以含有不同類型的數據。

元組不能被修改，不能刪除、修改元組中的元素，但可以用del刪除整個元組。

元組用小括號()表示。

tuple1=()#空元組

tuple2=(1,4,3)

tuple3=(1,"ok",[1,2,3])#類型不同&&嵌套

列表、元組之間的轉換

1、list(tup)將元組轉換為列表

myTuple=(1,2,3)print(list(myTuple))#[1, 2, 3]

"""python的內置函數list(tup)可以將元組轉換為列表，并返回該列表

此函數不會修改元組本身，myTuple仍是元組，本身不會變成列表"""

2、tuple(list)將列表轉換元組

myList=[1,2,3]print(tuple(myList))#(1, 2, 3)

"""python的內置函數tuple(list)可以將列表轉換為元組，并返回該元組

此函數不會修改列表本身，myList仍是列表，本身不會變成元組"""

這2種方法均不會修改列表、元組本身。