Python 列表

列表（list）作为 Python 中最常用的数据类型之一，是一个可增加、删除元素的可变（mutable）容器。

列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其他自定义类型的对象。

获取列表中的元素

列表中的每个元素都有一个下标索引，第一个索引是0，第二个索引是1，依此类推。可以使用下标索引来访问列表中的元素：

# 列表元素示例 
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 ]

添加元素

1、append()

L.append(元素m)：在列表L最后添加一个元素m，一次添加一个元素，并且只能在列表最后；

#定义列表L，默认有3个元素
L = ['xiaoWang','xiaoZhang','xiaoHua']
print(L)
temp = 'XiaoYu'
L.append(temp)
print(L)
---------------------------------------
['xiaoWang', 'xiaoZhang', 'xiaoHua']
['xiaoWang', 'xiaoZhang', 'xiaoHua', 'XiaoYu']

2、 extend()

L.extend([元素A，元素B，……])：对特定列表进行扩展和增长，可以一次添加多个元素，只能添加在列表的最后；

a = [1, 2]
b = [3, 4]
a.extend(b)
print(a)
-------------------------------------
[1, 2, 3, 4]

3、insert()

L.insert(A,元素B)：在列表L里面的索引A处加入元素B；

a = [0, 1, 2]
a.insert(1, 3)
print(a)
------------------------------
[0, 3, 1, 2]

删除元素

1、del L[n]

删除掉列表L里面的索引号位置为n 的元素，这里需要注意的是del是一种操作语句；

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print(movieName)

del movieName[2]
print(movieName)
---------------------------------------------------------------------------
['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']
['加勒比海盗', '骇客帝国', '指环王', '霍比特人', '速度与激情']

2、L.pop()

将列表L的最后一个元素返回，并且在此基础上进行删除；

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print(movieName)

m = movieName.pop()
print(movieName)
print(m)
-------------------------------------------------------------------------
['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']
['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人']
速度与激情

3、L.remove(A)

移除掉列表L里面的第一个特定元素A；

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情','指环王']
print(movieName)

movieName.remove('指环王')
print(movieName)
--------------------------------------------------------------------------------
['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情', '指环王']
['加勒比海盗', '骇客帝国', '第一滴血', '霍比特人', '速度与激情', '指环王']

修改元素

先通过索引来确定要修改的元素，然后重新赋值进行修改；

# 示例
A = ['xiaoWang','xiaoZhang','xiaoHua']
A[1] = 'xiaoYu'
print(A)
-------------------------------------------
['xiaoWang', 'xiaoYu', 'xiaoHua']

查找元素

1、in，not in

判断一个元素是否存在（不存在）于列表中

# 待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
# 要查找的名字
findName = 'xiaoYu'
if findName in nameList:
    print('1')
else:
    print('2')
if findName not in nameList:
    print('3')
else:
    print('4')
-----------------------------------------------------
2
3

2、index，count

L.index(a,m,n)：获取元素a在索引在m到n-1的列表L中的索引值；

L.count(a)：获取元素a在列表L中出现的次数；

L = ['a', 'b', 'c', 'a', 'b']
print(L.index('a', 1, 3)) # 注意是左闭右开区间
print(L.index('a', 1, 4))
print(L.index('a'))
print(L.count('b'))
print(L.count('d'))
------------------------------------------------
ValueError   Traceback (most recent call last)
ValueError: 'a' is not in list    # 因为在L[1:3]中不存在a，所以第一个print会出现报错
3
0
2
0

排序

1、sort()

用法：list.sort(cmp=None, key=None, reverse=False)

  • cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

sort()是可变对象(字典、列表)的方法，无返回值，sort()会改变可变对象，因此无需返回值。sort()方法是可变对象独有的方法或者属性，而作为不可变对象如元组、字符串是不具有这些方法的，如果调用将会返回一个异常。

a = [5,7,6,3,4,1,2]
b = a.sort()
print(a)
print(b)
-----------------------------
[1, 2, 3, 4, 5, 6, 7]
None

2、sorted()

sorted()不是可变对象(列表、字典)的特有方法，sorted()函数需要一个参数(列表、字典、元组、字符串)，无论传递什么参数，都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。

mystring="54321"
mytuple=(5,4,3,2,1)
mylist=[5,4,3,2,1]
a = sorted(mystring)
b = sorted(mytuple)
c = sorted(mylist)
print(a)
print(b)
print(c)
-----------------------------------
['1', '2', '3', '4', '5']
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

3、reverse()

反转排序，把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。

a = [5,4,3,2,1]
a.reverse()
print(a)
-------------------------
[1, 2, 3, 4, 5]

拷贝

import copy
 
a = [[1,2],10,20]
a1 = a  #第1种
a2 = a[:]  #第2种
a3 = list(a)  #第3种
a4 = a*1  #第4种
a5 = copy.copy(a)  #第5种
a6 = [x for x in a]  #第6种
a7 = copy.deepcopy(a)  #第7种
 
a.append(30)
a[0].append(3)
 
print('a:',a)
print('a1:',a1)
print('a2:',a2)
print('a3:',a3)
print('a4:',a4)
print('a5:',a5)
print('a6:',a6)
print('a7:',a7)
-----------------------------------------------
a: [[1, 2, 3], 10, 20, 30]
a1: [[1, 2, 3], 10, 20, 30]
a2: [[1, 2, 3], 10, 20]
a3: [[1, 2, 3], 10, 20]
a4: [[1, 2, 3], 10, 20]
a5: [[1, 2, 3], 10, 20]
a6: [[1, 2, 3], 10, 20]
a7: [[1, 2], 10, 20]

a1 = a 表示 a1 和 a 指向同一个内存地址，只是名称不同。

a2~a6 则是指向不同的列表，因为创建新的列表，所以原列表发生改变时，拷贝列表不变，但是里面元素本身的地址并没有改变，所以如果子元素为列表时，子元素列表在拷贝时地址并不会发生变化，所以当原列表中子列表发生改变时，拷贝列表同样会发生改变。

a7 是深度拷贝，所以无论列表中嵌套了几层列表，拷贝列表都不会随着原列表的改变而改变。

元组

Python的元组与列表类似，元组是不可变（immutable）对象，自然也就没有增加、删除元素的方法。元组使用小括号，列表使用方括号。

创建

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = （）
tup2 = （24，）
tup3 = ('php', 'python', 27, 300)

访问元组

元组可以使用下标索引来访问元组中的值。

tup1 = ('php', 'python', 27, 300)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
---------------------------------
tup1[0]:  php
tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但可以对元组进行连接组合。

tup1 = ('php', 'python', 27, 300)
tup2 = (1, 2, [56, 'java'] )
tup = tup1 + tup2
print(tup)
---------------------------------------
('php', 'python', 27, 300, 1, 2, [56, 'java'])

删除元组

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组。

tup = ('php', 'python', 27, 300)
print tup
del tup
print tup
----------------------------------
('php', 'python', 27, 300)
NameError   Traceback (most recent call last)
<ipython-input-10-142d96e04d75> in <module>()
      2 print(tup)
      3 del tup
----> 4 print(tup)
NameError: name 'tup' is not defined

内置函数

函数

描述

cmp(tuple1, tuple2)

比较两个元组元素。

len(tuple)

计算元组元素个数。

max(tuple)

返回元组中元素最大值。

min(tuple)

返回元组中元素最小值。

tuple(seq)

将列表转换为元组。