pythonlist拷貝
㈠ python其實很簡單 第九章 列表與元組（一）
在前面，我們要保存一個數據，需要先定義一個變數，而且一個變數中只能保存一個數據。譬如，語句：a1=1，值「1」就被保存了，但要保存「2」，就還需要再定義一個變數：a2=2......這樣以來，隨著數據的增多，豈不是要定義更多的變數嗎？
可以使用一個新的數據類型，它記錄很多數據，並且將它們按照順序存儲在連續的內存空間中，這便是序列。Python中有5種常用的序列結構，分別是列表、元組、集合、字典和字元串。
9.1列表
語法格式：
listname=[element1,element2,element3,......,elementn]
其中，listname為列表名，element1,element2,element3,......,elementn表示列表中的元素。各個元素的數據類型可以相同，也可以不同，但通常元素的類型都是相同的，含義也是相同的。
如：
list1=[『風』,』馬『,』牛』,1,2,3,』a』,』b』,』c』]就沒有太多的實際用途。
list2=['張三','男',18,�']雖然元素的類型不同，但表示了同一個人的信息。
1、訪問列表元素
列表中元素的索引號從0開始標記，訪問列表元素時，可以直接按照索引號讀取。
如：
list2=['張三','男',18,�']
print(list2[1]) #輸出列表中索引號為1的元素
輸出結果：男
和字元串一樣，序列都是可以使用切片操作的。
如：
print(list2[:2])
輸出結果：['張三', '男']
print(list2[2:])
輸出結果：[18, �']
2、使用range()函數創建數值列表
格式：range(start, stop [,step]) ；start 指的是計數起始值，默認是 0；stop 指的是計數結束值，但不包括 stop ；step 是步長，默認為 1，不可以為 0 。range() 方法生成一段左閉右開的整數范圍。
可以使用range()函數創建數值列表，如：
list1=list(range(10,20,2))
print(list1)
運行結果：[10, 12, 14, 16, 18]
3、刪除列表
語法格式如下：
del listname
其中，listname為要刪除列表的名稱。
刪除列表與刪除變數的方法是完全一樣的，前面已經介紹過了。
4、遍歷列表
常用的遍歷列表的方法有是利用for語句，舉例如下：
list1=list(range(10))
for item in list1:
print(item,end=' ') # end=』 『表示以空格結束，如果不寫這個參數，相當於默認值end=』 』
輸出結果：0 1 2 3 4 5 6 7 8 9
為了獲取列表元素的索引值，就需要使用enumerate()函數。
list1=list(range(10,20,2))
for index,item in enumerate(list1):
print(index,'-',item,end=' ')
輸出結果：0 - 10 1 - 12 2 - 14 3 - 16 4 - 18
5、追加、修改和刪除列表元素
追加元素
>>> list1=['春','夏','秋']
>>> list1.append('冬')
>>> list1
['春', '夏', '秋', '冬']
還有一種方法，就是使用「+」號將兩個序列連接起來。如：
list1=['春','夏','秋']
list1=list1+['冬']
print(list1)
輸出結果為：['春', '夏', '秋', '冬']
注意，下面的做法是錯誤的：
>>> list1=['春','夏','秋']
>>> list1=list1+'冬'
Traceback (most recent call last):
File " ", line 1, in
list1=list1+'冬'
TypeError: can only concatenate list (not "str") to list
從這個提示可知，列表只能與列表連接，而不能與字元串連接。
修改元素
>>> list1[2]='autumn' #通過索引對元素直接賦值
>>> print(list1)
['春', '夏', 'autumn', '冬']
刪除元素
>>> del list1[2] #通過索引直接刪除元素
>>> print(list1)
['春', '夏', '冬']
6、列表元素排序
在討論列表元素排序時，為了將有序列表變成無序列表，這里用到了shuffle()函數，但它不是Python的內置函數，需要先使用import語句將random模塊包含進來，這樣才能像使用內置函數那樣使用擴展模塊中的函數。
>>> import random #導入random模塊
>>> list1=list(range(10)) #生成列表，元素為0到9的整數。
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(list1) #用random包中的shuffle()函數將list1中元素次序打亂
>>> list1
[8, 6, 3, 5, 0, 7, 1, 9, 2, 4]
>>> list1.sort() #對list1升序排列
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(list1) #將list1順序重新打亂
>>> list1
[5, 9, 7, 8, 4, 3, 2, 0, 6, 1]
>>> list1.sort(reverse=True) #對list1降序排列
>>> list1
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
方法sort()的語法格式：
listname.sort(key=None,reverse=False)
其中，listname表示要排序的列表；key表示指定一個鍵，如」key=str.lower」表示排序時不區分字母大小寫；reverse為True表示降序排列（為默認值，可省缺），為False表示升序排列。
還有一個函數sorted()，功能與方法sort()相似。格式如下：
sorted(listname,key=None,reverse=False)
7、 利用列表推導式快速生成一個列表
例1：生成指定范圍的數值列表。
>>> import random
>>> list1=[random.randint(0,20) for i in range(10)]
>>> list1
[16, 20, 19, 6, 5, 7, 10, 5, 12, 5] #生成了包含10個值在0到20之間的元素構成的列表。
例2：根據現有列表生成新的列表。
>>> radius=list(range(1,6)) #生成列表 radius保存半徑的值
>>> radius
[1, 2, 3, 4, 5]
>>> s=[round(2*3.14*r,2) for r in radius]
#生成列表s，將計算得到的周長值保存起來，其中round（）可以保留指定小數位，格式 round(var, n)，var為變數名，n為指定保留小數位。
>>> s
[6.28, 12.56, 18.84, 25.12, 31.4]
例3：從列表中選擇符合條件的元素組成新的列表。
>>> score=[98,65,77,56,82,89] #列表score用來存儲成績
>>> good=[x for x in score if x>=80]
#從列表score中選取>=80的元素存入新列表good中
>>> good
[98, 82, 89]
count()、index()和sum()方法
count()方法
用於統計指定元素在列表中出現的次數。
例：
>>> list1=['a','b','c','d','e','f','c','d','e','a','b','c','d']
>>> num=list1.count('c') #統計列表list1中'c'的個數
>>> num
3
index()方法
用於獲取指定元素在列表中第一次出現的索引值。
>>> list1=['a','b','c','d','e','f','c','d','e','a','b','c','d']
>>> position=list1.index('c')
>>> position
2
sum()方法
用於計算數值列表中全部或指定元素的和。
>>> list1=[1,2,3,4,5]
>>> total=sum(list1) #計算列表list1中全部元素的和
>>> total
15
>>> total=sum(list1,1) #在列表list1全部元素的和後，在加上參數（「1」）的值
>>> total
16
>>> total=sum(list1[:2]) #計算切片list1[:2]中各元素的和
>>> total
3
二維列表
格式：listname[下標1][下標2]
其中，listname表示列表的名稱，下標1表示列表中的行號，下標2表示列表中的列號。對於n行m列的二維列表，第一個元素的行號和列號都是0，最後一個元素的行號和列號都是n-1。如下所示：
list[0][0] list[0][1] list[0][2] ............ list[0][m-1]
list[1][0] list[1][1] list[1][2] ............ list[1][m-1]
......
......
list[n-1][0] list[n-1][1] list[n-1][2] ............ list[n-1][m-1]
通俗地講，如果一個列表中的元素本身就是一個列表，則這個列表就是一個二維列表。
如：
>>> list1=['a1','b1','c1','d1']
>>> list2=['a2','b2','c2','d2']
>>> list3=['a3','b3','c3','d3']
>>> listtwo=[list1,list2,list3]
>>> listtwo
[['a1', 'b1', 'c1', 'd1'], ['a2', 'b2', 'c2', 'd2'], ['a3', 'b3', 'c3', 'd3']]
如果要查看二維列表listtwo按照行、列的排列，可以運行如下代碼：
for i in range(3):
for j in range(4):
print(listtwo[i][j],end=' ')
print()
運行結果：
a1 b1 c1 d1
a2 b2 c2 d2
a3 b3 c3 d3
如果要讀取二維列表中的某一行，可以使用如下方法：
>>> listtwo[2] #讀取第3行的元素（注意索引號都是從0開始的）
['a3', 'b3', 'c3', 'd3']
如果要讀取某一個元素的值，可以使用如下方法：
>>> listtwo[2][2] #讀取第3行第3列的元素
'c3'
㈡ python，兩個list相等,比如a=b。然後後一個變了，為什麼前一個也跟著變怎麼才能不變
b=a 是指將b指向了a 同一個列表，並不是復制了一份列表。
所以修改任肆罩何一個時，實際是笑姿修改的同一個列表。
如果要復制，使用（淺拷貝） deep（深碰雹絕拷貝）
具體介紹，你查一下吧
㈢ python把列表前幾個元素提取到新列表
python把列表前幾個元素提取到新列表步驟如下：
1、打開python語言命令窗口，定義一個列表變數C並進行賦值。
㈣ 深入探究Python中變數的拷貝和作用域問題
這篇文章主要介紹了Python中變數的拷貝和作用域問題,包括一些賦值、引用問題,以及相關函數在Python2和3版本之間的不同,需要的朋友可以參考下
在
python
中賦值語句總是建立對象的引用值，而不是復制對象。因此，python
變數更像是指針，而不是數據存儲區域，
這點和大多數
OO
語言類似吧，比如
C++、java
等
~
1、先來看個問題吧：
在Python中，令values=[0,1,2];values[1]=values,為何結果是[0,[...],2]?
?
1
2
3
4
>>>
values
=
[0,
1,
2]
>>>
values[1]
=
values
>>>
values
[0,
[...],
2]
我預想應當是
?
1
[0,
[0,
1,
2],
2]
但結果卻為何要賦值無限次?
可以說
Python
沒有賦值，只有引用。你這樣相當於創建了一個引用自身的結構，所以導致了無限循環。為了理解這個問題，有個基本概念需要搞清楚。
Python
沒有「變數」，我們平時所說的變數其實只是「標簽」，是引用。
執行
?
1
values
=
[0,
1,
2]
的時候，Python
做的事情是首先創建一個列表對象
[0,
1,
2]，然後給它貼上名為
values
的標簽。如果隨後又執行
?
1
values
=
[3,
4,
5]
的話，Python
做的事情是創建另一個列表對象
[3,
4,
5]，然後把剛才那張名為
values
的標簽從前面的
[0,
1,
2]
對象上撕下來，重新貼到
[3,
4,
5]
這個對象上。
至始至終，並沒有一個叫做
values
的列表對象容器存在，Python
也沒有把任何對象的值復制進
values
去。過程如圖所示：
執行
?
1
values[1]
=
values
的時候，Python
做的事情則是把
values
這個標簽所引用的列表對象的第二個元素指向
values
所引用的列表對象本身。執行完畢後，values
標簽還是指向原來那個對象，只不過那個對象的結構發生了變化，從之前的列表
[0,
1,
2]
變成了
[0,
?,
2]，而這個
?
則是指向那個對象本身的一個引用。如圖所示：
要達到你所需要的效果，即得到
[0,
[0,
1,
2],
2]
這個對象，你不能直接將
values[1]
指向
values
引用的對象本身，而是需要吧
[0,
1,
2]
這個對象「復制」一遍，得到一個新對象，再將
values[1]
指向這個復制後的對象。Python
裡面復制對象的操作因對象類型而異，復制列表
values
的操作是
values[:]
#生成對象的拷貝或者是復制序列，不再是引用和共享變數，但此法只能頂層復制
所以你需要執行
?
1
values[1]
=
values[:]
Python
做的事情是，先
dereference
得到
values
所指向的對象
[0,
1,
2]，然後執行
[0,
1,
2][:]
復制操作得到一個新的對象，內容也是
[0,
1,
2]，然後將
values
所指向的列表對象的第二個元素指向這個復制二來的列表對象，最終
values
指向的對象是
[0,
[0,
1,
2],
2]。過程如圖所示：
往更深處說，values[:]
復制操作是所謂的「淺復制」(shallow
)，當列表對象有嵌套的時候也會產生出乎意料的錯誤，比如
?
1
2
3
4
a
=
[0,
[1,
2],
3]
b
=
a[:]
a[0]
=
8
a[1][1]
=
9
問：此時
a
和
b
分別是多少?
正確答案是
a
為
[8,
[1,
9],
3]，b
為
[0,
[1,
9],
3]。發現沒?b
的第二個元素也被改變了。想想是為什麼?不明白的話看下圖
正確的復制嵌套元素的方法是進行「深復制」(deep
)，方法是
?
1
2
3
4
5
6
import
a
=
[0,
[1,
2],
3]
b
=
.deep(a)
a[0]
=
8
a[1][1]
=
9
2、引用
VS
拷貝：
(1)沒有限制條件的分片表達式(L[:])能夠復制序列，但此法只能淺層復制。
(2)字典
方法，D.()
能夠復制字典，但此法只能淺層復制
(3)有些內置函數，例如
list，能夠生成拷貝
list(L)
(4)
標准庫模塊能夠生成完整拷貝：deep
本質上是遞歸
(5)對於不可變對象和可變對象來說，淺復制都是復制的引用，只是因為復制不變對象和復制不變對象的引用是等效的(因為對象不可變，當改變時會新建對象重新賦值)。所以看起來淺復制只復制不可變對象(整數，實數，字元串等)，對於可變對象，淺復制其實是創建了一個對於該對象的引用，也就是說只是給同一個對象貼上了另一個標簽而已。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
L
=
[1,
2,
3]
D
=
{'a':1,
'b':2}
A
=
L[:]
B
=
D.()
print
"L,
D"
print
L,
D
print
"A,
B"
print
A,
B
print
"--------------------"
A[1]
=
'NI'
B['c']
=
'spam'
print
"L,
D"
print
L,
D
print
"A,
B"
print
A,
B
L,
D
[1,
2,
3]
{'a':
1,
'b':
2}
A,
B
[1,
2,
3]
{'a':
1,
'b':
2}
--------------------
L,
D
[1,
2,
3]
{'a':
1,
'b':
2}
A,
B
[1,
'NI',
3]
{'a':
1,
'c':
'spam',
'b':
2}
3、增強賦值以及共享引用：
x
=
x
+
y，x
出現兩次，必須執行兩次，性能不好，合並必須新建對象
x，然後復制兩個列表合並
屬於復制/拷貝
x
+=
y，x
只出現一次，也只會計算一次，性能好，不生成新對象，只在內存塊末尾增加元素。
當
x、y
為list時，
+=
會自動調用
extend
方法進行合並運算，in-place
change。
屬於共享引用
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
L
=
[1,
2]
M
=
L
L
=
L
+
[3,
4]
print
L,
M
print
"-------------------"
L
=
[1,
2]
M
=
L
L
+=
[3,
4]
print
L,
M
[1,
2,
3,
4]
[1,
2]
-------------------
[1,
2,
3,
4]
[1,
2,
3,
4]
4、python
從2.x
到3.x，語句變函數引發的變數作用域問題
先看段代碼：
?
1
2
3
4
5
6
7
8
9
def
test():
a
=
False
exec
("a
=
True")
print
("a
=
",
a)
test()
b
=
False
exec
("b
=
True")
print
("b
=
",
b)
在
python
2.x
和
3.x
下
你會發現他們的結果不一樣：
?
1
2
3
4
5
6
7
2.x：
a
=
True
b
=
True
3.x：
a
=
False
b
=
True
這是為什麼呢?
因為
3.x
中
exec
由語句變成函數了，而在函數中變數默認都是局部的，也就是說
你所見到的兩個
a，是兩個不同的變數，分別處於不同的命名空間中，而不會沖突。
具體參考
《learning
python》P331-P332
知道原因了，我們可以這么改改：
?
1
2
3
4
5
6
7
8
9
10
11
12
def
test():
a
=
False
ldict
=
locals()
exec("a=True",globals(),ldict)
a
=
ldict['a']
print(a)
test()
b
=
False
exec("b
=
True",
globals())
print("b
=
",
b)
這個問題在
stackoverflow
上已經有人問了，而且
python
官方也有人報了
bug。。。
具體鏈接在下面：
http://stackoverflow.com/questions/7668724/variables-declared-in-execed-code-dont-become-local-in-python-3-documentatio
http://bugs.python.org/issue4831
http://stackoverflow.com/questions/1463306/how-does-exec-work-with-locals
㈤ python語句list執行結果
Python語句list(range(1,10,3))執行結果為[1,4,7]。
語法是:range(start,stop[,step])
參數說明：
（1）start:計數從start開始，默認是從0開始。例如range(5)等價於range(0,5);
（2）stop:計數到stop結束，但不包括stop。例如：range(0,5)是[0,1,2,3,4]沒有5;
（3）step：步長，默認為1。例如：range(0,5)等價於range(0,5,1)。
因此，range(1,10,3)的意思是1到10之間的tuple，間隔為3，所以結果是(1,4,7)。
列表(List)是最常用的Python數據類型，它可以作為一個方括弧內的逗號分隔值出現。
所以，list(range(1,10,3))執行結果為[1,4,7]。
(5)pythonlist拷貝擴展閱讀
Python列表函數&方法
Python包含以下函數：
1、亂運cmp(list1, list2)：比較兩個列表的元素；
2、len(list)：列表元素個數；
3、max(list)：返回列表元素最大值；
4、min(list)：返回列表元素最小值；
5、list(seq)：將元組轉換為列表。
Python包含以下方法：
1、list.append(obj)：在列表末尾添加新的對象；
2、list.count(obj)：統計某個元芹陪鬧素在列表中出現的次數；
3、list.extend(seq)：在列表末尾一次性追加另嫌罩一個序列中的多個值（用新列表擴展原來的列表）；
4、list.index(obj)：從列表中找出某個值第一個匹配項的索引位置；
5、list.insert(index, obj)：將對象插入列表；
6、list.pop([index=-1])：移除列表中的一個元素（默認最後一個元素），並且返回該元素的值；
7、list.remove(obj)：移除列表中某個值的第一個匹配項；
8、list.reverse()：反向列表中元素；
9、list.sort(cmp=None, key=None, reverse=False)：對原列表進行排序。
㈥ python3對於列表的 [:]和list. 有什麼區別
我們日常所說的復制（自己在電腦硬碟上的復制）就是深復制（deep），即將被復制對象完全再復制一遍作為獨立的新個體單獨存在。所以改變原有被復制對象不會對已經復制出來的新對象產生影響。
而淺復制（）並不會產生一個獨立的對象單獨存在，他只是將原有的數據塊打上一個新標簽，所以當其中一個標簽指向的數據塊就會發生變化，另一個標簽也會隨之改變。這就和我們尋常意義上的復制有所不同了。
㈦ Python中list的實現
原文鏈接
這篇文章介紹了Python中list是如何實現的。
在Python中list特別有用。讓我們來看下list的內部是如何實現的。
來看下面簡單的程序，在list中添加一些整數並將他們列印出來。
正如你所看到的，list是可以迭代的。
Python中list是用下邊的C語言的結構來表示的。 ob_item 是用來保存元素的指針數組，allocated是 ob_item 預先分配的內存總容量
讓我們來看下當初始化一個空list的時候發生了什麼 L = []
非常重要的是知道list申請內存空間的大小（後文用allocated代替）的大小和list實際存儲元素所佔空間的大小( ob_size )之間的關系， ob_size 的大小和 len(L) 是一樣的，而allocated的大小是在內存中已經申請空間大小。通常你會看到allocated的值要比 ob_size 的值要大。這是為了避免每次有新元素加入list時都要調用realloc進行內存分配。接下來我們會看到更多關於這些的內容。
我們在list中追加一個整數:L.append(1)。發生了什麼？調用了內部的C函數app1()
來讓我們看下 list_resize() , list_resize() 會申請多餘的空間以避免調用多次 list_resize() 函數，list增長的模型是:0, 4, 8, 16, 25, 35, 46, 58, 72, 88, …
開辟了四個內存空間來存放list中的元素，存放的第一個元素是1。你可以從下圖中看到L[0]指向了我們剛剛加進去的元素。虛線的框代表了申請了但是還沒有使用(存儲元素)的內存空間
現在我們在列表的第一個位置插入一個整數5:L.insert(1, 5),看看內部發生了什麼。調用了ins1()
當你彈出list的最後一個元素：L.pop()。調用listpop()， list_resize 在函數listpop()內部被調用，如果這時 ob_size （譯者註：彈出元素後）小於allocated（譯者註：已經申請的內存空間）的一半。這時申請的內存空間將會縮小。
Pop的時間復雜度是O(1)
Python list對象有一個方法可以移除一個指定的元素。調用listremove()。
切開list和刪除元素，調用了 list_ass_slice() （譯者註：在上文slice list between element's slot and element's slot + 1被調用），來看下 list_ass_slice() 是如何工作的。在這里，低位為1 高位為2（譯者註：傳入的參數），我們移除在1號內存空間存儲的數據5
Remove的時間復雜度為O(n)
文中list的sort部分沒有進行翻譯
核心部分
㈧ python 列表操作的一個問題
一、創建一個列表
只要把逗號分隔的不同的數據項使用方括弧括起來即可。如下所示：
復制代碼代碼如下:
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
與字元串的索引一樣，列表索引從0開始。列表可以進行截取、組合等。
二、訪問列表中的值
使用下標索引來訪問列表中的值，同樣你也可以使用方括弧的形式截取字元，如下所示：
復制代碼代碼如下:
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
以上實例輸出結果：
復制代碼代碼如下:
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]
三、更新列表
你可以對列表的數據項進行修改或更新，你也可以使用append()方法來添加列表項，如下所示：
復制代碼代碼如下:
#!/usr/bin/python
list = ['physics', 'chemistry', 1997, 2000];
print "Value available at index 2 : "
print list[2];
list[2] = 2001;
print "New value available at index 2 : "