python----列表list和元组

责任声明：
在写这篇文章之前，本人阅读了众多python列表的知识总结，所以文中会有很多来自其他前辈的博文的内容，但本人无意冒犯，只是为了方便自己回顾。

列表是一种数据类型，列表中的值成为表项，表项之间用逗号分隔。
方法是一种函数，方法与特定的某种数据类型绑定在一起，所以，列表有着他自己独特的各种方法。

列表排序，sort（）是永久排序，sorted（）方法是不永久排序.

下标

1、表项下标只能是整数，不能是浮点值。
2、负数下标，-1代表最后一个，-2代表倒数第二个

切片

切片实现了一次从列表中取出、操作多个表项。切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
list[m:n:p]
每次隔p-1个表项取一个，但是位序之差为p
list[m:m+n] 从m开始，取n个
list[ :n] 取前n个
list[-1:] 取最后一个
list[ :-1]
切片都是左闭右开

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::]                             #返回包含所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::-1]                           #逆序的所有元素
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList[::2]                            #偶数位置，隔一个取一个
[3, 5, 7, 11, 15]
>>> aList[1::2]                           #奇数位置，隔一个取一个
[4, 6, 9, 13, 17]
>>> aList[3::]                            #从下标3开始的所有元素
[6, 7, 9, 11, 13, 15, 17]
>>> aList[3:6]                             #下标在[3, 6)之间的所有元素
[6, 7, 9]
>>> aList[0:100:1]                       #前100个元素，自动截断
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[100:]                            #下标100之后的所有元素，自动截断
[]

可以使用切片来原地修改列表内容

>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9]                       #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3]                            #替换前3个元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = []                                        #删除前3个元素
>>> aList
[9]
>>> aList = list(range(10))
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[::2] = [0]*5                                  #替换偶数位置上的元素
#不能写成aList[::2] = 0	或者aList[::2] = [0]

a = list(range(10))
a[-3:] = [9]*3
a[9] = 0
print(a)
#[0, 1, 2, 3, 4, 5, 6, 9, 9, 0]

a = list(range(10))
a[len(a):] = [1,2,3]
print(a)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3]

切片返回的是浅拷贝

>>> a=[1,2,[1,2]]
>>> b = a[:]
>>> b
[1, 2, [1, 2]]
>>> a == b
True	#这只证明了a和b的表项值相等
>>> a is b
False	#说明a和b的引用并不一样

>>> a[0]=9
>>> b
[1, 2, [1, 2]]
>>> a == b
False

由上一步的操作可知，==判断的是值是否相等，is判断的是引用是否一样（更严格）

#接上面的操作
>>> a[2][0] = 9
>>> b
[1, 2, [9, 2]]

如果原列表中包含列表之类的可变数据类型，由于浅复制时只是把子列表的引用复制到新列表中，这样的话修改任何一个都会影响另外一个。

对列表的处理函数

1、len(list)，求list列表的表项的个数。
2、del list[ n ]，删除掉list列表的n下标的表项，也可以del列表切片，一次删除多个表项。
3、zip（）
zip()函数分别从a和b依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器

>>> a = [0, 1, 2, 3]
>>> b = [1, 2, 3, 4, 5, 6]
>>> c = zip(a,b)
>>> type(c)
<class 'zip'>

>>>> print(list(c))	#可以将其转化为列表
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> print(dict(zip(a,b)))	#可以将其转化为字典
{0: 1, 1: 2, 2: 3, 3: 4}

4、random.shuffle(list)
打乱列表的顺序

>>> import random
>>> a = list(range(10))
>>> random.shuffle(a)
>>> a
[5, 1, 6, 4, 8, 2, 3, 7, 0, 9]

5、list()，创建列表，可以创建空列表，也可以把其他迭代器（字符串、元组、集合、字典）的变量转换为列表。

#创建空列表
>>> test = list()
>>> test
[]
#字符串，并不是这个字符串是一个表项，而是把字符串拆开。
>>> test = list('cat')
>>> test
['c', 'a', 't']
#元组
>>> a_tuple = ('I love Python.', 'I also love HTML.')
>>> test = list(a_tuple)
>>> test
['I love Python.', 'I also love HTML.']
#字典，仅仅抽出键
>>> a_dict = {'China':'Beijing', 'Russia':'Moscow'}
>>> test = list(a_dict)
>>> test
['China', 'Russia']
#集合
>>> a_set = {1, 4, 'sdf'}
>>> test = list(a_set)
>>> test
[1, 'sdf', 4]

list（）需要注意的，参数必须是迭代器类型的，

>>> test = list(12)		#单纯的int变量是不行的，要么就放在元组或者集合里面
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

7、sorted(list , reverse = True)
内置函数sorted()对列表进行排序并返回新列表，不同于list.sort()，他不会改变列表本身。
8、其他用于迭代器的内置函数：sum（），max（），min（）

其他对列表的处理

1、列表拼接：
list_1 + list_2，返回一个新的列表
2、列表复制：
list * 整数n
当使用 *运算符将包含列表的列表重复并创建新列表时，并不是复制子列表值，而是复制已有元素的引用。因此，当修改其中一个值时，相应的引用也会被修改。

>>> x = [[None] * 2] * 3
>>> x
[[None, None], [None, None], [None, None]]
>>> x[0][0] = 5
>>> x
[[5, None], [5, None], [5, None]]

3、遍历列表：
for i in list
for i in range(len(list)):
  print(“第”+str(i+1)+“个变量是”+list[i]
4、判断表项是否在列表中
in  not in

in和not in只会判断一层

>>> b = [[1], [2，9], [3，4]]
>>> 3 in b
False#in和not in只会判断一层

5、多重赋值
var_1,var_2,var_3 = list[-3 : ]  #变量个数和列表长度必须匹配

列表方法

index、append、insert、remove、sort、pop、clear、reverse、count、extend、copy
1、list.index(value，[start],[end])
start和end用来设置查找范围。
如果存在就返回下标，如果列表中没有要查找的表项就会报错ValueError

2、list.append(value)
在列表的最后添上value表项，可以使用+进行列表和列表的拼接，但拼接不能操作列表和表项

3、list.insert(n,value)
在下标n前插入表项value，（那么他也就成为了下标n）。
如果是将一个列表活或者切片插入，就会将这个一维列表变为二维列表

4、list.remove(value)
根据表项值删除，那么就不能删除本身就不存在的表项值，否则VauleError
del根据下标删除，remove根据表项值删除，但是del不是列表固有方法。

5、list.sort( key=None, reverse=False )
把数字列表按升序排列，把字符串列表按照字母表的顺序A - Z，可以排列数字、字符串，但是不能排列数字和字符串混合在一起的列表，对于字符串的排列，Z比a在前面。
对列表list中的元素进行排序，key用来指定排序依据，reverse决定升序（False），还是降序（True）
如果要忽略大小写，需要使用key参数

spam = ["Alice","Bob","Zack","zack","alic"]
spam.sort(key = str.lower)
print(spam)
['alic', 'Alice', 'Bob', 'Zack', 'zack']

逆序排序需要使用reverse参数

spam.sort(reverse = True)

6、list.pop([index])
删除并返回列表list中下标为index（默认为-1）的元素
7、list.clear()
删除列表list中所有元素，但保留列表对象
8、list.reverse()
对列表list所有元素进行逆序。也可以考虑使用切片方法list[ : : -1]
9、list.count(value)
返回指定值value在列表list中的出现次数
10、list.extend(L)
将列表、切片L或者其他迭代器型变量中所有元素添加至列表list尾部。相比于使用+拼接，这个方法运行更快，并且不会改变列表的id
11、list.copy()
返回列表list的浅拷贝。
如果是二维的，则二维部分返回的是引用，不是值。

注意点：

1、字符串也可以使用很多列表的方法，但是，list是可变类型的，字符串是不可变的。可以使用字符串的某些值我，但是对字符串的直接修改是会报错的。
正确：

s = "hello world"
s[3:]
'lo world'

错误：

s = "hello world"
s[3] = "d"#错误

2、深浅拷贝 以及引用拷贝
深拷贝和浅拷贝以及引用拷贝都是对于引用类型的数据而言，对于非引用型的，请看下方代码演示。

>>> a = 2
>>> b = a
>>> id(a) == id(b)
True	#将a赋值给b，此时a和b的id是一样的。
>>> b = 4
>>> id(a) == id(b)
False	#对b的值修改之后，a和b的id不再一样
>>> id(b) == id(4)
True

据此可知，非引用类型（包括常量）和引用类型都有id，b=a这个赋值并不代表着a和b绑定在一起了，并不意味着对b的修改会影响a的值。

列表之间用等号的直接赋值是引用拷贝，两个列表的表项值，一改全改。
这里介绍copy库，可以使用copy库的copy()和deepcopy()，前者是浅拷贝，后者是深拷贝。
对于浅拷贝，如果列表的表项是一个列表时，copy（）就会返回内层列表的引用，而不是值，这时要使用深拷贝deepcopy（）。

spam = ["Alice","Bob","Zack","zack","alic"]
new = copy.copy(spam)

列表引用拷贝的实现：
（1）使用等号=，直接用一个列表对另一个列表赋值

列表浅拷贝的实现：
（1）使用copy库的copy（）方法
（2）使用切片对另一个列表赋值

列表深拷贝的实现：
（1）使用copy库的deepcopy（）方法

但是注意，如果是二维列表，那么直接采用一次（一层）浅拷贝，赋值过去的是第二层列表的引用，所以对于内层的列表而言仍然是等号赋值的引用拷贝。

3、map()函数，返回一个迭代器，可以转化为list
map(function, iterable, …)
  function – 函数
  iterable – 一个或多个序列，一般函数有几个参数，就会需要几个列表

>>> def square(x) :            # 计算平方数
		return x ** 2
>>> list(map(square, [1,2,3,4,5]))   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
#lambda匿名函数可以作为函数，例如上面的代码可以表示为
>>> list(map(lambda x: x**2, [1,2,3,4,5]))
[1, 4, 9, 16, 25]

#用到两个列表的map
>>> list(map(lambda x,y: x+y, [1,2,3,4,5],[3,4,5,6,7,9]))
[4, 6, 8, 10, 12]

知识分支：lambda匿名函数

>>> plus = lambda x,y:x+y
>>> plus(4,6)
10

元组

元组和列表十分相似，元组使用圆括号包括起来表项，而不是方括号。
和字符串一样，元组也是不可变类型的，还有一点要注意，在声明元组时，如果元组中只有一个表项，那就需要在最后加上一个逗号，免得python因为这只是括号中的一个整数数字或者字符串。

元组和列表之间的转换

使用list( )和tuple( )

l = ["Alice","Bob","Zack","zack","alic"]
t = ("qq",23,"l")
l_ = list(t)
t_ = tuple(l)