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