序列-列表

常用的序列结构：字符串 元祖 字典 集合

列表对象大小可变，根据需要随时增加或缩小

列表创建的四种方式

一、基本语法[]创建

a = []
print(a)  #结果，创建空的列表 []

b = [1,2,"abc"]
print(b)      #结果：[1, 2, 'abc']
print(b[2])   #结果：abc

二、list()创建

c = list()
print(c)      #结果：创建一个空的列表
c.append(1)
print(c)      #结果：[1]
c = list("abcdefg")
print(c)      #结果：['a', 'b', 'c', 'd', 'e', 'f', 'g']
d = list(range(10))
print(d)      #结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

三、range()创建整数列表
range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：

range([start],end ,[step])
start 参数：可选，表示起始数字。默认是 0
end   参数：必选，表示结尾数字。
step  参数：可选，表示步长，默认为 1e = list(range(0,10,2))
print(e)      #结果：[0, 2, 4, 6, 8]f = list(range(10,0,-1))
print(f)      #结果：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]g = list(range(-10,-30,-2))
print(g)      #结果：[-10, -12, -14, -16, -18, -20, -22, -24, -26, -28]

四、推导式生成列表(简介一下，重点在 for 循环后讲)

h = [x*2 for x in range(10)] #循环创建多个元素
print(h)      #结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]k = [x*2 for x in range(100) if x%9==0] #通过if过滤元素
print(k)      #结果：[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

创建列表的增加和删除

append（）方法
在列表中添加元素：在列表末尾添加元素
方法append()将元素添加到列表末尾，不影响列表中其他所有元素。列表名.append(‘新的元素名’)，可以创建一个空列表，使用一系列append()语句添加元素
例如：在students列表末尾增加"Gavin"项。

>>>students = [‘Cleese‘ , ‘Palin‘ , ‘Jones‘ , ‘Idle‘]
>>> students.append(‘Gavin‘)
>>> print(students)
[‘Cleese‘, ‘Palin‘, ‘Jones‘, ‘Idle‘, ‘Gavin‘]

+方法
地址会发生变化，也就是创建了新的列表对象

insert()
在列表中插入元素：使用方法insert()可在列表的任何位置添加新元素，需要制定新元素的索引和值。列表名.insert(索引，‘值’)
insert（）方法是指在某个特定位置前面增加一个数据项。
例如：在students原始列表中"Palin"前面增加"Gilliam"。

>>> students = [‘Cleese‘ , ‘Palin‘ , ‘Jones‘ , ‘Idle‘]
>>> students.insert(1, ‘Gilliam‘)
>>> print(students)
[‘Cleese‘, ‘Gilliam‘, ‘Palin‘, ‘Jones‘, ‘Idle‘]。

extend（）方法
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象
例如：在例1基础上，students列表末尾继续增加"Kavin"与"Jack"和"Chapman"三项。

>>> students = [‘Cleese‘ , ‘Palin‘ , ‘Jones‘ , ‘Idle‘]
>>> students.insert(1, ‘Gilliam‘)
>>> print(students)
[‘Cleese‘, ‘Gilliam‘, ‘Palin‘, ‘Jones‘, ‘Idle‘]。

del删除
del的书写方式是 del list[i] 根据索引删除，也就是根据位置删除元素。

L = [1,2,2,3,4,5,6,7,8,9]
del L[0],L[3:6]
print(L)>>>[2, 2, 3, 7, 8, 9]
#注意上面的操作，是先删除L[0]之后重新排序L = [1,2,3]
del L
print（L)错误：name 'L' is not defined,#表示已经被删除

pop的使用
pop的书写方式是 list.pop[i] 根据索引返回对应位置的元素，列表也删除相对于位置的元素。list.pop（）删除列表最后一个元素，并返回这个元素。

L = [1,2,2,3,4,5,6,7,8,9]
a = L.pop(2)
print(L)
print(a)>>>[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>2L = [6,7,8,9]
L.pop()
print(L)[6, 7, 8]

remove的使用
remove的书写方式是 list.remove(value) 删除第一个出现的对应元素，注意不是根据索引删除。而是确定列表种有某个元素，删除它。

    L = [1,2,2,3,4,5,6,7,8,9]L.remove(2)print(L)>>>[1, 2, 3, 4, 5, 6, 7, 8, 9]L.remove(2)print(L)>>>[1, 3, 4, 5, 6, 7, 8, 9]

删除的本质是数组元素的拷贝

列表元素访问和技术

index（）获得指定元素在列表指定范围

>>> alist
[1, 3, 5, 5.5, 3, 5, 1, 3, 5]
>>> alist.index(3)
1
>>> alist.index(100)
Traceback (most recent call last):File "<pyshell#102>", line 1, in <module>alist.index(100)
ValueError: 100 is not in list

count（）获得指定元素在列表中出现的次数

>>> alist
[1, 3, 5, 5.5, 3, 5, 1, 3, 5]
>>> alist.count(3)
3
>>> alist.count(5)
3
>>> alist.count(4)
0

len（）返回列表长度

#!/usr/bin/pythonlist1, list2 = [123, 'xyz', 'zara'], [456, 'abc']print "First list length : ", len(list1);
print "Second list length : ", len(list2);

成员资格判断
判断是否存在指定的值
1.count（）方法，如果存在则返回大于0的数，如果返回0则表示不存在。
2.“in”关键字来判断一个值是否存在于列表中，返回结果为“True”或“False”。

>>> alist
[1, 3, 5, 5.5, 3, 5, 1, 3, 5]
>>> 3 in alist
True
>>> 18 in alist
False

结果：

First list length :  3
Second lsit length :  2

列表排序

sort
sorted()：该函数第一个参数iterable为任意可以迭代的对象，cmp是比较函数，通常为lambda函数，key是用于比较的关键字，reverse表示排序结果是否反转。
这里需要注意的一点是，调用 L.sort() 完成排序后，改变了要排序的列表的结构

A = [3,6,1,5,4,2]
A.sort()  // [1, 2, 3, 4, 5, 6]

student = [['Tom', 'A', 20], ['Jack', 'C', 18], ['Andy', 'B', 11]]
student.sort(key=lambda student: student[2])学生列表中包含列表，每个列表是学生的姓名、成绩以及年龄，排序过程中指定了key为学生的年龄，所以排序的结果为：[['Andy', 'B', 11], ['Jack', 'C', 18], ['Tom', 'A', 20]]

student = [['Tom', 'A', 20], ['Jack', 'C', 18], ['Andy', 'B', 11]]
student.sort(cmp=lambda x, y: x[2] - y[2])

通过定义 key 和 cmp 都可以完成排序，但是这两者之间有什么区别呢？cmp传入的函数在整个排序过程中会调用多次，因为会进行多次比较，所以函数调用开销较大，因此使用 key 的效率比 cmp 的效率要高。

sorted
L.sort()：该函数的三个参数和 sorted() 的后三个参数含义是一致的，而需要特别注意的是，该函数只适用于列表，而非任意可以迭代的对象。cmp是比较函数，接受两个对象参数 x 和 y，返回 负数(x<y)，0(x=y)，正数(x>y)

sorted()可以应用于任意的可以迭代的对象，所以应用范围比L.sort() 广泛的多，可以应用于字符串，元组，列表，字典等可迭代对象。

即可以保留原列表，又能得到已经排序好的列表sorted()操作方法如下：

>>> a = [5,7,6,3,4,1,2]
>>> b = sorted(a)
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]

需要注意的是，该函数会返回一个排序后的列表，原有可迭代对象保持不变，这与 L.sort() 函数不同。然而，这会浪费较大的存储空间，尤其是数据量较大时。所以，在列表进行排序时，需要考虑是否需要保存原列表，如果无需保存原列表，则优先使用L.sort() 节省内存空间，提高效率。
总结：
L.sort() 函数只适用于列表排序，而sorted()函数适用于任意可以迭代的对象排序。

L.sort() 函数排序会改变原有的待排序列表，而sorted()函数则不会改变。所以在使用列表进行排序时，需要考虑是否需要保存原列表，如果无需保存原列表，则优先使用L.sort() 节省内存空间，提高效率。

两个函数通过定义 key 和 cmp 都可以完成排序，但是 key 的效率要远远高于 cmp，所以要优先使用 key 。

reversed（）返回迭代器

max和min sum

list = [1,2,3,4,5,6,7,8,9,10]max = max(list)
min = min(list)
sum = sum(list)print("max:",max)
print("min:",min)
print("sum:",sum)输出结果：
max: 10
min: 1
sum: 55

二维列表

表格数据的存取和读取

在 Matlab 中我们可以用 save 和 lood 函数很方便的实现。类似的在 Python 中，我们可以用 numpy.save() 和 numpy.load() 函数达到类似的效果，并且还可以用 scipy.io.savemat() 将数据保存为 .mat 格式，用scipy.io.loadmat() 读取 .mat 格式的数据，达到可以和 Matlab 或者Octave 进行数据互动的效果.

numpy.save() 和 numpy.load()
numpy.save(arg_1,arg_2) 需要两个参数，arg_1 是文件名，arg_2 是要保存的数组. 如：

import numpy as np
a=np.mat('1,2,3;4,5,6')
b=np.array([[1,2,3],[4,5,6]])
np.save('a.npy',a)
np.save('b.npy',b)

这个时候 Python 的当前工作路径下就会多出 a.npy 和 b.npy 两个文件，当然我们也可以给出具体的路径，如 np.save(‘D:/PythonWork/a.npy’,a)

下面我们把保存的这两个数据文件导入到Python :

data_a=np.load('a.npy')
data_b=np.load('b.npy')
print ('data_a \n',data_a,'\n the type is',type(data_a))
print ('data_b \n',data_a,'\n the type is',type(data_b))

输出结果为：

data_a
[[1 2 3]
[4 5 6]]
the type is <class 'numpy.ndarray'>data_b
[[1 2 3]
[4 5 6]]
the type is <class 'numpy.ndarray'>

我们可以看到这一过程把原本为矩阵的 a 变为数组型了，如果想同时保存 a b 到同一个文件，我们可以用 np.savez() 函数，具体用法如下：

np.savez('ab.npz',k_a=a,k_b=b)
c=np.load('ab.npz')
print (c['k_a'])
print (c['k_b'])

输出结果为：

[[1 2 3]
[4 5 6]][[1 2 3]
[4 5 6]]

至此 Python 的当前工作路径下就多了 a.mat 和 b.mat 这两个文件.

下面我们用 Matlab 读取这两个文件：
见链接：https://blog.csdn.net/weixin_40446557/article/details/88219673