python列表、元组、Numpy数组及矩阵的相关总结

参考博客：https://blog.csdn.net/guliang21/article/details/88566158
https://blog.csdn.net/wyl1813240346/article/details/79806207

内容说明

      本文主要是对python列表、元组、Numpy数组的相关用法进行总结归纳，对三种容器的联系与区别进行辨析，帮助读者更清晰的了解python编程中这三类容器的用法。

一、三类容器的基本用法介绍

      该部分内容，主要是介绍三类容器各自的基本及常用操作。对这些基本操作较为了解的读者，可以跳过该部分内容直接进入第二小节。

   1、list列表的基本用法

      列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。在Python中，用方括号（[]）来表示列表，并用逗号来分隔其中的元素。列表中的每个元素都有确定的位置，或称索引，第一个元素的索引是0，第二个索引是1，依此类推。
创建列表：

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

访问列表中的元素：

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print(list1[0])
print(list1[-1])
print(list2[1])

运行结果为：

physics
2000
2

注意：在索引中，索引号“-1”指列表中倒数第一个元素。

修改、添加和删除元素：
（1）修改元素
例如，假设有一个摩托车列表，其中的第一个元素为’honda’，如何修改它的值呢？

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles[0] = 'ducati'
print(motorcycles)

运行结果为：

['honda', 'yamaha', 'suzuki']
['ducati', 'yamaha', 'suzuki']

（2）在列表中添加元素
在列表末尾添加元素：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)

motorcycles.append('ducati')
print(motorcycles)

运行结果为：

['honda', 'yamaha', 'suzuki']
['honda', 'yamaha', 'suzuki', 'ducati']

      通过append函数，即可在列表末尾添加元素。方法append()让动态地创建列表易如反掌，例如，你可以先创建一个空列表，再使用一系列的append()语句添加元素。

在列表中插入元素：
      使用方法insert()可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)

运行结果为：

['ducati', 'honda', 'yamaha', 'suzuki']

      方法insert()在索引0处添加空间，并将值’ducati’存储到这个地方。这种操作将列表中既有的每个元素都右移一个位置。

（3）从列表中删除元素
使用del语句删除元素

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[0]
print(motorcycles)

运行结果为：

['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']

      del motorcycles[0]则可直接删除列表 motorcycles中的第一个元素。使用del可删除任何位置处的列表元素，条件是知道其索引。

使用方法pop()删除元素
      方法pop()可删除列表末尾的元素，并让你能够接着使用它。术语弹出（pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)

popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)

运行结果为：

['honda', 'yamaha', 'suzuki']
['honda', 'yamaha']
suzuki

      即通过pop用法，将 motorcycles列表中的末尾元素“suzuki”删除了，删除之后，将该元素赋值给了popped_motorcycle。
实际上，pop方法的功能还可以更强大。只要知道列表中某个元素的索引，就可以将其从列表中弹出。

motorcycles = ['honda', 'yamaha', 'suzuki']
first_owned = motorcycles.pop(0)
print('The first motorcycle I owned was a ' + first_owned.title() + '.')

运行结果为：

The first motorcycle I owned was a Honda.

      代码中，.title()的功能是将字符串的首位改为大写。
      如果你不确定该使用del语句还是pop()方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方pop()。

（4）列表切片操作
      要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[1:4])

运行结果为：

['martina', 'michael', 'florence']

      要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[2:])

运行结果为：

['michael', 'florence', 'eli']

      无论列表多长，这种语法都能够让你输出从特定位置到列表末尾的所有元素。本书前面说过，负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。例如，如果你要输出名单上的最后三名队员，可使用切片players[-3:]：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:])

运行结果为：

['michael', 'florence', 'eli']

   2、元组（Tuple）的基本用法

      列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

运行结果为：

200
50

      虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组：

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
   print(dimension)
dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
   print(dimension)

运行结果为：

Original dimensions:
200
50
Modified dimensions:
400
100

   3、Nunpy数组的基本用法

      Numpy 是 Python 中科学计算的核心库，NumPy 这个词来源于 Numerical 和 Python 两个单词。它提供了一个高性能的多维数组对象，以及大量的库函数和操作，可以帮助程序员轻松地进行数值计算，广泛应用于机器学习模型、图像处理和计算机图形学、数学任务等领域。
（1）Numpy 数组：ndarray
      NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型，它是描述相同类型的元素集合。ndarray 中的每个元素都是数据类型对象(dtype)的对象。ndarray 中的每个元素在内存中使用相同大小的块。

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

参数	描述
object	任何暴露数组接口方法的对象
dtype	数据类型
copy	如果为 True，则 object 对象被复制，否则，只有当__array__返回副本，object 是嵌套序列，或者需要副本来满足任何其他要求（dtype，order等）时，才会生成副本。
order	指定阵列的内存布局。 如果 object 不是数组，则新创建的数组将按行排列（C），如果指定了（F），则按列排列。 如果 object 是一个数组，则以下成立。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）
subok	默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回子类。
ndmin	返回数组的最小维数

示例代码：

import numpy as np

a = [1, 2, 3]
b = np.array(a)

print(b)
print(type(b))

输出：

[1 2 3]
<class 'numpy.ndarray'>

注意：list 打印显示是 [1, 2, 3]，而 ndarray 打印显示是 [1 2 3]，当中没有逗号。

dtype 参数用法示例：

import numpy as np

a = [1, 2, 3]
b = np.array(a, dtype=np.float_)
# 或者
b = np.array(a, dtype=float)

print(b)
print(b.dtype)
print(type(b[0]))

输出：

[1. 2. 3.]
float64
<class 'numpy.float64'>

copy 参数的用法：

示例代码：

import numpy as np

a = np.array([1, 2, 3])
b = np.array(a, copy=True)
a[0] = 0

print(a)
print(b)

输出：

[0 2 3]
[1 2 3]

可以看到 a 和 b 的值不同，说明 b 是 a 的副本，两个是不同的对象。

ndmin 参数用法示例：
示例代码：

import numpy as np

a = [1, 2, 3]
b = np.array(a, ndmin=2)

print(b)

输出：

[[1 2 3]]

（2）NumPy 数组属性

      NumPy 数组的维度（又称维数）称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。NumPy 中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。

ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.ravel	可将多维数组展平，转为一维。

      注：ndarray.shape 返回一个包含数组维度的元组，对于矩阵，n 行 m 列，它也可以用于调整数组维度。
示例代码：

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)
b.shape = (3, 2)
print(a)
print(b)

输出：

(2, 3)
[[1 2]
 [3 4]
 [5 6]]

      NumPy 也提供了reshape() 函数来调整数组维度。只是 reshape() 返回调整维度后的副本，而不改变原 ndarray。

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
b = a.reshape(3, 2)
print(b)  # a 没变

输出：

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

ndarray.ndim返回数组的维度（秩）。

import numpy as np

a = np.arange(24)
print(a.ndim)

# 现在调整其大小
b = a.reshape(2, 4, 3)
print(b.ndim)

输出：

1
3

ndarray.size 的功能为计算数组元素的总个数，相当于 .shape 中 n*m 的值。

import numpy as np

a = np.array([[1.0,1.0,1.0],[1.0,1.0,1.0]])
print(a.size)

输出：

6

ndarray.dtype的功能为返回数组元素的数据类型：

import numpy as np

a = np.array([[1.0,1.0,1.0],[1.0,1.0,1.0]])
print(a.dtype)

输出：

float64

ndarray.ravel的功能为，将高维数组转化为1维数组：

import numpy as np

a = np.array([[1.0,1.0,1.0],[1.0,1.0,1.0]])
print(a.ravel())

输出：

[1. 1. 1. 1. 1. 1.]

（3）NumPy 创建数组

numpy.zeros 创建指定维度，以 0 填充的新数组。

numpy.zeros(shape, dtype=float, order='C')

numpy.ones创建指定维度，以 1 填充的新数组。

numpy.ones(shape, dtype=float, order='C')

numpy.full返回给定维度和类型的新数组，填充 fill_value。

numpy.full(shape, fill_value, dtype=None, order='C')

（4）NumPy 数组数据类型及转化
首先，numpy数据类型共有：

显示数据类型及类型转换：

>>> import numpy as np
>>> arr=np.array([1,2,3,4,5])
>>> arr.dtype
dtype('int32')
>>> float_arr=arr.astype(np.float64)
>>> float_arr
array([1., 2., 3., 4., 5.])
>>> float_arr.dtype
dtype('float64')

>>> arr_string=np.array(['1.24','2.6','21'],dtype=np.string_)
>>> arr_string.astype(float)
array([ 1.24,  2.6 , 21.  ])

注意：

1.使用numpy.string_类型时，一定要小心，因为NumPy的字符串数据是大小固定的，发生截取时，不会发出警告。pandas提供了更多非数值数据的便利的处理方法。

2.调用astype总会创建一个新的数组（一个数据的备份），即使新的dtype与旧的dtype相同。

二、三类容器的区别

      该部分内容，主要是从用法及含义上来辨析三类容器的区别。

   1、list列表与numpy数组

      Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。使用Python列表可以存储一维数组，通过列表的嵌套可以实现多维数组，那么为什么还需要使用Numpy呢？Numpy是专门针对数组的操作和运算进行了设计，所以数组的存储效率和输入输出性能远优于Python中的嵌套列表，数组越大，Numpy的优势就越明显。通常Numpy数组中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以在通用性能方面Numpy数组不及Python列表，但在科学计算中，可以省掉很多循环语句，代码使用方面比Python列表简单的多。
列表转为数组：
（1）转成数组的matrix对象，使用np.mat()方法。

In [1]: a = [[2,3,4],[4,7,1]]                                                                                                                                                                 
 
In [2]: np.mat(a)                                                                                                                                                                             
Out[2]: 
matrix([[2, 3, 4],
        [4, 7, 1]])

（2）转成数组的ndarray对象，使用np.array()方法。

In [1]: a = [[2,3,4],[4,7,1]]  
In [2]: np.array(a)                                                                                                                                                                           
Out[2]: 
array([[2, 3, 4],
       [4, 7, 1]])

数组转列表：
      numpy中的数组和矩阵转换为列表需要注意用tolist（）方法，如果用list（）函数则会构造出一个新的列表，此列表的元素是原来的数组或矩阵了。

>>> matrix_1 = np.mat([[7, 8, 9], [0, 5, 3]])
>>> matrix_1
matrix([[7, 8, 9],
        [0, 5, 3]])
>>> #矩阵转化为数组
>>> array_1 = np.array(matrix_1)
>>> array_1
array([[7, 8, 9],
       [0, 5, 3]])
>>> #矩阵转化为列表
>>> list_1 = matrix_1.tolist()
>>> list_1
[[7, 8, 9], [0, 5, 3]]
 
>>> list_1 = list(matrix_1)
>>> list_1
[matrix([[7, 8, 9]]), matrix([[0, 5, 3]])]


>>> array_2 = np.array([[1, 5, 9], [3, 5, 7]])
>>> array_2
array([[1, 5, 9],
       [3, 5, 7]])
>>> #数组转化为矩阵
>>> matrix_2 = np.mat(array_2)
>>> matrix_2
matrix([[1, 5, 9],
        [3, 5, 7]])
>>> #数组转化为列表
>>> list_2 = array_2.tolist()
>>> list_2
[[1, 5, 9], [3, 5, 7]]
 
>>> list_2 = list(array_2)
>>> list_2
[array([1, 5, 9]), array([3, 5, 7])]

   2、Numpy数组和矩阵的区别：

1. Numpy matrices必须是2维的,但是 numpy arrays (ndarrays) 可以是多维的（1D，2D，3D····ND）. Matrix是Array的一个小的分支，包含于Array。所以matrix 拥有array的所有特性。
2. 在numpy中matrix的主要优势是：相对简单的乘法运算符号。例如，a和b是两个matrices，那么a*b，就是矩阵积。
3. matrix 和 array 都可以通过objects后面加.T 得到其转置。但是 matrix objects 还可以在后面加 .H f得到共轭矩阵, 加 .I 得到逆矩阵。
4. 相反的是在numpy里面arrays遵从逐个元素的运算，所以array：c 和d的c*d运算相当于matlab里面的c.*d运算。而矩阵相乘，则需要numpy里面的dot命令 。