python列表与元组

一. 列表（list）

1. 表示方法：用方括号括起来的一系列元素的集合，如：

#列表不是c数组，一个列表可以包括各种类型
list_tmp  = [] #空列表
list_tmp2 = [3.14, "san shi", True, None, [1, 2, 3]]

print(list_tmp2[3])	#None
print(list_tmp2[4][1]) 	#2

注意：索引值不能超出范围，否则报错。
索引值为-1时表示最后一个元素，依此类推。

2. 列表切片、连接、复制（操纵整个列表）

list_tmp1 = [1, 2, 3]
list_tmp2 = list_tmp1[:] #左边默认为0，右边默认为len(list)
list_tmp3 = list_tmp1[0:1] #[1]。即使是一个元素，结果也是列表
list_tmp4 = list_tmp1[0:-1] #[1, 2]

切片与range()相似，都是左闭右开区间，不包括右边索引。

list_tmp1 = [1, 2]
list_tmp2 = [3, 4]
list_tmp3 = list_tmp1 + list_tmp2 #[1, 2, 3, 4]
list_tmp4 = list_tmp1 * 2 #[1, 2, 1, 2]
list_tmp4 += [0] #即使只是‘+’一个数字，也必须将数字放在一个列表中

3. 遍历列表

list_tmp1 = [1, 2, 3]
#逐个打印列表值
for i in list_tmp1:
    print(i)

#打印每一个元素索引与值
for index in range(len(list_tmp1)):
    print("list_tmp1[{0}] = {1}" .format(index, list_tmp1[index]))

4. 列表的删除

list_tmp = [1, 2, 3]
del(list_tmp[1])
#tmp = del(list_tmp[1]) 非法，del直接删除，不会将删除的元素返回
print(list_tmp) #[1, 3]
del(list_tmp) #del整个list_tmp，之后不可以再访问list_tmp

del删除的值你没办法再访问。

5. 元素是否在列表中,返回值为True/False

list_tmp = ["san", "shi"]
if ("san" in list_tmp):
    print("True") #打印True
else:
    print("False")

"san" not in list_tmp #False

6. 将列表同时赋值给多个变量

list_tmp   = [0, 1]
num1, num2 = list_tmp #num1 = 0, num2 = 1
#列表元素数目必须与赋值变量数目相同

#遍历dict就类似这种
dict_tmp = {"san":0, "shi":1}
for name, age in dict_tmp.items():
    print("{0}'s age is {1}" .format(name, age))

二. 列表的方法

1. 查找元素方法：index、count

list_tmp = ["san", "shi", "san", [1, 2]]
print(list_tmp.index("san")) #0,返回第一个index
print(list_tmp.index([1, 2])) #3
#print(list_tmp.index("xxx")) 元素不存在会报错
print(list_tmp.count("san")) #2，有多少个查找的元素，没有返回0

如果元素存在则返回第一次出现的索引，不存在则报错。
我自己写了一个简单的函数可以返回所有index：
可以点击此链接跳转

2. 添加元素方法：insert、append

list_tmp = [0, 5]
list_tmp.append(10) #在列表尾部插入元素。[0, 5, 10]
list_tmp.insert(1, 3) #在index为1处插入元素。[0, 3, 5, 10]
list_tmp.append([1, 2]) #插入列表
list_tmp.append({0:0, 1:1}) #插入dict

insert与append返回值均为None。
insert的index超过列表长度，在我的电脑上与append作用相同。

3. 删除元素方法：remove、pop、clear

list_tmp = ["san", "shi", "san"]
list_tmp.remove("san") #删除第一个"san"
print(list_tmp.pop()) #删除最后一个元素并返回最后一个元素
list_tmp.clear() #队列清空

返回值为None，如果删除值在队列中不存在会报错。
知道要删除值的索引使用del删除，del索引超过长度也会报错。
pop空队列也会报错，可以选择先len(list)看是否为0。
clear与del不同，del后内存空间直接释放，队列已经不存在，clear只是把队列中的值删除掉，队列还在。
总之就是python提供一些检查，更加安全。
4. 排序元素方法：sort、reverse

list_tmp = [1, 5, 3, 2]
list_tmp.reverse() #[2, 3, 5, 1]将队列反着排列
list_tmp.sort() #[1, 2, 3, 5]，进行排序

sort还有key参数与reverse参数。reverse参数默认为False，为正序，设置为True则反序。key表示以什么方式进行排序。

5. 这里给出文档中队列的所有方法，文档还是简单明了
   

三. 元组（tuple）

1. 元组表示：

tuple_tmp1 = () #空元组
tuple_tmp = ("san", ) #只有一个元素的元组，必须要加逗号

2. 元组是不可变类型，任何更改元组内容的操作都是非法的。
3. 元组的方法只有index与count，其他类似列表的操作都没有。

四. 元组与列表互换

1. 使用tuple()将列表或字典转换为元组

list_tmp = [1, 2]
dict_tmp = {"san":0, 123:1}
print(tuple(list_tmp)) #(1, 2)
print(tuple(dict_tmp)) #("san", 123)

字典转换为tuple只是将key转换。

2. 使用list()将元组或字典转换为列表

tuple_tmp = (1, 2)
dict_tmp = {"san":0, 123:1}
print(list(tuple_tmp)) #[1, 2]
print(list(dict_tmp)) #["san", 123]

同tuple()，字典转换为list只是将key转换。

五. 值还是引用

1. 不可变类型是值

num1 = 10
num2 = num1 #为num2开辟空间，并将num1中的值复制到num2，从此num1与num2再无关系
num2 = 15
print(num1) #10
print(num2) #15

数字、字符串、元组都是不可变类型，不可以作为左值，所以是值的方式。

2. 可变类型是引用

list1 = [1, 2]
list2 = list1 #将list1对应的内存空间的地址给list2，二者指向同一块内存空间
list2.append(3)
print(list1) #[1, 2, 3]
print(list2) #[1, 2, 3]

列表与dict是可变类型，可以作为左值，所以是引用的方式。
函数参数是列表或字典要注意可以在函数内部修改外部的值。

3. 使用copy模块

import copy

#copy
list1 = [1, 2]
list2 = copy.copy(list1) #此时为重新开辟一块内存空间并拷贝，而不是引用
list2.insert(len(list2), 3)
print(list1) #[1, 2]
print(list2) #[1, 2, 3]

#deepcopy()
list1 = [1, [1, 2]] 
#若使用copy，列表内部的列表还是引用，所以要用deepcopy
list2 = copy.deepcopy(list1)