python三维函数库 python三维数据
使用Matplotlib模拟Python中的三维太阳系
编程的一个用途是通过模拟来帮助我们理解真实世界。这一技术被应用于科学、金融和许多其他定量领域。只要控制现实世界属性的“规则”是已知的，你就可以编写一个计算机程序来 探索 你遵循这些规则所得到的结果。在本文中，您将 用Python模拟三维太阳系 使用流行的可视化库Matplotlib
建网站原本是网站策划师、网络程序员、网页设计师等，应用各种网络程序开发技术和网页设计技术配合操作的协同工作。成都创新互联专业提供成都网站设计、网站建设,网页设计,网站制作(企业站、成都响应式网站建设公司、电商门户网站)等服务,从网站深度策划、搜索引擎友好度优化到用户体验的提升,我们力求做到极致!
在这篇文章，你将能够用Python创建你自己的3D太阳系，你可以用你想要的多少太阳和行星。下面是一个简单的太阳系的一个例子，它有一个太阳和两个行星：
你还可以打开动画地板上的二维投影，更好地展示太阳系的三维本质。下面是同样的太阳系模拟，包括2D投影：
下面是这篇文章的概要，以便您知道接下来会发生什么：
在本文中，您将使用面向对象的编程和Matplotlib。如果您希望阅读更多关于任何一个主题的内容，您可以阅读：
让我们从使用Matplotlib在Python中模拟一个3D太阳系开始。
太阳系中的太阳、行星和其他天体都是运动中的天体，它们相互吸引。引力在任何两个物体之间施加。
如果这两个对象有大量M_1和M_2是距离r然后，你可以用以下公式计算它们之间的引力：
常数G是一个引力常数。您将看到如何在模拟的版本中忽略这个常量，在本文中，您将使用任意单位的质量和距离，而不是kg和m。
一旦你知道了两个物体之间的引力，你就可以计算出加速度。a每个物体都是由于这种引力而经历的，使用以下公式：
使用这个加速度，你可以调整运动物体的速度。当速度发生变化时，速度和方向都会发生变化。
当用Python模拟一个三维太阳系时，你需要用三维空间来表示太阳系。因此，这个3D空间中的每个点都可以用三个数字来表示， x -, y -和 z -坐标。例如，如果你想把太阳放在太阳系的中心，你可以将太阳的位置表示为 (0, 0, 0) .
您还需要在3D空间中表示向量。矢量具有大小和方向。你需要像速度、加速度和力这样的量的矢量，因为这些量都有一个方向和一个震级。
在本文中，我将不详细讨论向量代数。相反，我将陈述您需要的任何结果。你可以读到更多关于向量与向量代数如果你愿意的话。
为了在代码中更容易地处理向量，您可以创建一个类来处理它们。编写这个类将作为对类和面向对象编程的快速刷新。你可以读到用Python进行面向对象的编程如果你觉得你需要一个更彻底的解释。虽然您也可以创建一个类来处理3D空间中的点，但这并不是必要的，在本文中我也不会创建一个类。
如果您熟悉向量和面向对象编程，可以跳过本节，只需在定义 Vector 班级。
创建一个名为 vectors.py 中，您将定义 Vector 班级。您将使用此脚本定义类并对其进行测试。然后，可以删除最后的测试代码，只需在这个脚本中保留类定义：
这个 __init__() 方法的 Vector 类有三个参数，表示每个轴上的值。每个参数的默认值为 0 表示该轴的原点。虽然我们不喜欢在Python中使用单个字母名称， x , y ，和 z 是恰当的，因为它们代表了数学中常用的笛卡尔坐标系的术语。
您还定义了两个Dunder方法来将对象表示为一个字符串：
在代码段的末尾，您可以更多地了解这两种类型的字符串表示之间的差异。Python编码书第9章 .
测试代码块的输出如下：
在Python项目中的这个3D太阳系中，如果 Vector 类是可索引的，以便您可以使用 [] 带有索引以提取其中一个值的符号。使用当前形式的类，如果添加 print(test[0]) 在您的脚本中，您将得到一个 TypeError 说 Vector 对象不可订阅。您可以通过向类定义中添加另一个Dud方法来修复这个问题：
通过定义 __getitem__() ，你做了 Vector 可索引的类。向量中的第一项是 x 的价值。 y 的价值。 z 。任何其他索引都会引发错误。测试代码块的输出如下：
test[0] 返回向量中的第一个项， x .
可以定义类的对象的加法和减法。 __add__() 和 __sub__() DunderMethod.这些方法将使您能够使用 + 和 - 执行这些操作的符号。如果没有这些Dud方法，则使用 + 和 - 提出 TypeError .
若要添加或减去两个向量，可以分别添加或减去向量的每个元素：
双管齐下 __add__() 和 __sub__() 返回另一个 Vector 对象，每个元素等于两个原始向量中相应元素的加减。输出如下：
对于乘法和除法，您也可以这样做，尽管在处理向量时，这些操作需要更多的注意。
在处理向量时，不能仅仅引用“乘法”，因为有不同类型的“乘法”。在这个项目中，你只需要标量乘法。标量乘法是指向量与标量相乘(标量有一个数量级，但没有方向)。但是，在本小节中，您还将定义点积两个向量。你想用 * 运算符，既适用于标量乘法，也适用于点积。因此，可以定义 __mul__() DunderMethod：
使用 * 运算符将取决于第二个操作数，即 * 符号，是标量或向量。如果由参数表示的第二个操作数 other ，是类型的 Vector ，计算了点积。但是，如果 other 是类型的 int 或 float ，返回的结果是一个新的 Vector ，按比例调整。
以上代码的输出如下：
如果您想要标量乘法，则需要标量乘法。 后 这个 * 象征。如果您试图运行该语句 3*Vector(3, 5, 9) 相反， TypeError 将被提高，因为 Vector 类不是用于使用的有效操作数。 * 带有类型的对象 int .
两个向量是分不开的。但是，可以将向量除以标量。您可以使用 / 运算符 Vector 如果定义 __truep__() DunderMethod：
产出如下：
如果你有一个向量(x，y，z)，您可以找到它的震级使用表达式(x^2+y^2+z^2)。你也可以规范化向量。归一化给出一个方向相同但大小为 1 。您可以通过将向量的每个元素除以矢量的大小来计算归一化向量。
可以定义两个新方法来完成 Vector 班级：
测试代码提供了以下输出：
第三个输出给出了归一化向量的大小，表明它的大小是 1 .
根据使用的IDE或其他工具，在分割时可能会收到警告 self.x , self.y ，和 self.z ，如在 __truep__() 和 normalize() 。您不需要担心这个问题，但是如果您想要修复它，可以通过更改 __init__() 签署下列任何一项：
或
这两个选项都让IDE知道参数应该是浮动的。在第二个选项中，您使用类型暗示来实现。
您现在可以删除此脚本末尾的测试代码，以便您在 vectors.py 是类的定义。
现在，你可以开始研究Python中的3D太阳系了。您将创建两个主要类：
你将使用Matplotlib来创建和可视化太阳系。您可以在终端中使用以下内容来安装Matplotlib：
或
这个 Axes3D Matplotlib中的物体将“托管”太阳系。如果您使用过Matplotlib，并且主要使用了2D绘图，那么您将使用(有意或不知情的) Axes 对象。 Axes3D 的3D等效 Axes ，顾名思义！
现在是开始编写和测试这些类的时候了。您可以创建两个新文件：
接下来，您将开始处理 SolarSystem 班级。
您将在整个项目中使用任意单元。这意味着，与其用米作为距离，而用公斤作为质量，你将使用没有单位的数量。参数 size 用于定义包含太阳系的立方体的大小：
定义 SolarSystem 类的 __init__() 方法，其中包含参数。 size 。您还定义了 bodies 属性。这个属性是一个空列表，当你稍后创建它们时，它将包含太阳系内的所有天体。这个 add_body() 方法可以用来将轨道天体添加到太阳系中。
下一步是介绍Matplotlib。属性创建图形和一组轴。 subplots() 在 matplotlib.pyplot :
你打电话 plt.subplots() ，它返回一个图形和一组轴。返回的值分配给属性。 fig 和 ax 。你打电话 plt.subplots() 有以下论点：
您还可以调用该方法。 tight_layout() 。这是 Figure 类在Matplotlib中。此方法减少了图形边缘的边距。
到目前为止，您可以在控制台/REPL中尝试代码：
这给出了一组空的三维轴的图形：
您将使用 size 参数设置此多维数据集的大小。你会回到 SolarSystem 稍后上课。目前，您可以将您的注意力转向定义 SolarSystemBody 班级。
您可以开始创建 SolarSystemBody 类及其 __init__() 方法。我正在截断 SolarSystem 下面代码中的类定义用于显示。在此代码块和以后的代码块中，包含 # ... 指出您之前编写的未显示的代码：
中的参数。 __init__() 方法是：
你也叫 add_body() 方法中定义的 SolarSystem 类将这个天体添加到太阳系中。稍后，您将向 __init__() 方法。
中定义另一个方法。 SolarSystemBody 用其当前的位置和速度移动物体：
这个 move() 方法重新定义 position 属性的 velocity 属性。我们已经讨论过你是如何用任意单位来计算距离和质量的。你也在使用任意的时间单位。每个‘时间单位’将是循环的一个迭代，您将使用它来运行模拟。因此， move() 将身体按一次迭代所需的数量移动，这是一个时间单位。
你们已经创建了Matplotlib结构，它将容纳太阳系及其所有天体。现在，您可以添加一个 draw() 方法 SolarSystemBody 若要在Matplotlib图上显示主体，请执行以下操作。您可以通过绘制一个标记来完成这一任务。
在这样做之前，您需要在 SolarSystemBody 若要控制将绘制的标记的颜色和大小以表示身体，请执行以下操作：
类属性 min_display_size 和 display_log_base 设置参数，以确定您将在3D图上显示的标记的大小。您设置了一个最小的大小，以便您显示的标记不太小，即使对于小的身体也是如此。您将使用对数标度将质量转换为标记大小，并将此对数的基值设置为另一个类属性。
这个 display_size 属性中的实例属性。 __init__() 方法在计算的标记大小和所设置的最小标记大小之间进行选择。为了在这个项目中确定身体的显示大小，你要使用它的质量。
您还可以添加 colour 属性 __init__() ，暂时默认为黑色。
要测试这些新添加的内容，可以在控制台/REPL中尝试以下内容：
第一次呼叫 body.draw() 在原点绘制物体，因为你使用的是太阳系天体的默认位置。打电话给 body.move() 用一个“时间单位”所需的数量移动身体。因为身体的速度是 (1, 1, 1) ，身体将沿着三个轴中的每一个移动一个单位。第二次呼叫 body.draw() 在第二个位置画太阳系天体。请注意，当您这样做时，轴将自动重新排列。您很快就会在主代码中处理这个问题。
您可以返回到 SolarSystem 通过给太阳系及其天体添加两种新的方法，将其分类和连接起来： update_all() 和 draw_all() :
这个 update_all() 方法穿过太阳系中的每一个物体，移动并画出每一个物体。这个 draw_all() 方法使用太阳系的大小设置三轴的限制，并通过 pause() 功能。此方法还清除轴，为下一个绘图做好准备。
您可以开始构建一个简单的太阳系，并通过创建一个名为 simple_solar_system.py :
运行此脚本时，您将看到一个黑体从情节的中心移动：
您可以更改三维图形的透视图，这样您就可以直接沿着其中一个轴查看3D轴。可以通过将视图的方位和仰角设置为 0 在……里面 SolarSystem.__init__() :
跑动 simple_solar_system.py 现在给出以下观点：
这个 x -轴现在垂直于你的屏幕。因为你在2D显示器上显示一个3D视图，所以你总是有一个方向与你用来显示图形的2D平面垂直。这一限制使得很难区分物体何时沿该轴运动。你可以通过改变身体的速度 simple_solar_system.py 到 (1, 0, 0) 并再次运行脚本。身体似乎是静止的，因为它只是沿着轴移动，从你的屏幕出来！
您可以通过根据它的不同更改标记的大小来改进三维可视化。 x -协调。靠近您的对象看起来更大，而更远的对象看起来更小。您可以对 draw() 方法中的 SolarSystemBody 班级：
self.position[0] 表示身体的位置。 x -轴，即垂直于屏幕的轴。因子 30 除以是一个任意因素，您可以使用它来控制您希望这种效果有多强。
在本教程的后面，您还将添加另一个功能，将有助于可视化的三维运动的恒星和行星。
你有一个太阳系，里面有可以移动的物体。到目前为止，如果您只有一个身体，那么代码可以正常工作。但那不是一个非常有趣的太阳系！如果你有两个或两个以上的物体，它们就会通过相互的引力相互作用。
在这篇文章的开头，我简要回顾了你需要处理两个物体之间的引力的物理。由于在这个项目中使用的是任意单位，所以可以忽略引力常数 G 简单地计算出由于两个物体之间的重力而产生的力，如：
一旦你知道了两个物体之间的力，因为F=ma，您可以计算出每个对象必须使用的加速度：
一旦你知道加速度，你就可以改变物体的速度。
您可以添加两个新方法，一个在 SolarSystemBody 另一个在 SolarSystem ，计算出任何两个物体之间的力和加速度，并穿过太阳系中的所有物体，并计算它们之间的相互作用。
第一种方法计算出两个物体之间的引力，计算每个物体的加速度，并改变两个物体的速度。如果您愿意，可以将这些任务分为三种方法，但在本例中，我将将这些任务放在 SolarSystemBody :
accelerate_due_to_gravity() 对类型的对象调用。 SolarSystemBody 需要另一个 SolarSystemBody 身体作为一种争论。参数 self 和 other 代表两个身体相互作用。此方法的步骤如下：
现在你可以计算出任何两个天体之间的相互作用，你可以计算出太阳系中所有天体之间的相互作用。你可以把你的注意力转移到 SolarSystem 类的类：
这个 calculate_all_body_interactions() 方法贯穿太阳系的所有天体。每个天体与太阳系中的其他天体相互作用：
现在，您已经准备好创建一个简单的太阳系，并测试您到目前为止编写的代码。
在这个项目中，您将关注创建两种类型的天体之一：太阳和行星。您可以为这些机构创建两个类。新类继承自 SolarSystemBody :
这个 Sun 类的默认质量为10,000个单位，并将颜色设置为黄色。使用字符串 'yellow' ，这是Matplotlib中的有效颜色。
在 Planet 类创建一个 itertools.cycle 对象有三种颜色。在这种情况下，这三种颜色是红色、绿色和蓝色。你可以使用你想要的任何RGB颜色，也可以使用任意数量的颜色。在这个类中，使用带有RGB值的元组来定义颜色，而不是使用颜色名称的字符串。这也是在Matplotlib中定义颜色的有效方法。使用 next() 每当你创建一个新的行星时。
您还将默认质量设置为10个单元。
现在，你可以创建一个太阳系，其中一个太阳和两个行星在 simple_solar_system.py :
在这个脚本中，您创建了一个太阳和两个行星。你把太阳和行星分配给变量 sun 和 planets ，但这并不是严格要求的，因为 Sun 和 Planet 对象被创建，它们被添加到 solar_system 你不需要直接引用它们。
你用一个 while 循环来运行模拟。循环在每次迭代中执行三个操作。运行此脚本时，将获得以下动画：
它起作用了，算是吧。你可以看到太阳锚定在这个太阳系的中心，行星受到太阳引力的影响。除了行星在包含你电脑屏幕的平面上的运动(这些是 y -和 z --轴)，你也可以看到行星越来越大，因为它们也在 x -轴，垂直于屏幕。
然而，你可能已经注意到行星的一些奇怪的行为。当它们被安排在太阳后面时，行星仍然被展示在太阳的前面。这不是数学上的问题--如果你跟踪行星的位置，你会发现 x -坐标显示，它们实际上是在太阳后面，正如你所预料的那样。
这个问题来自Matplotlib在绘图中绘制对象的方式。Matplotlib按绘制对象的顺序将对象按层绘制。因为你在行星之前创造了太阳， Sun 对象放在第一位 solar_system.bodies 并作为底层绘制。您可以通过在行星之后创建太阳来验证这一事实，在这种情况下，您将看到行星总是出现在太阳后面。
你会希望Matplotlib按照正确的顺序绘制太阳系的天体，从最前的那些天体开始。要实现这一点，您可以对 SolarSystem.bodies 的值为基础的列表。 x -协调每次刷新3D图形的时间。下面是如何在 update_all() 方法 SolarSystem :
使用List方法 sort 带着 key 参数来定义要用于排序列表的规则。这个 lambda 函数设置此规则。在本例中，您使用的值是 position[0] 表示 x -协调。因此，每次你打电话 update_all() 在模拟中 while 循环中，根据其沿 x -轴心。
运行 simple_solar_system.py 现在的脚本如下：
现在，你可以想象行星的轨道，就像它们围绕太阳运行一样。不断变化的大小显示了它们的 x -位置，当行星在太阳后面时，它们被隐藏在视线之外！
最后，你也可以移除轴线和网格，这样你在模拟中看到的就是太阳和行星。可以通过添加对Matplotlib的调用来做到这一点。 axis() 方法 SolarSystem.draw_all() :
模拟现在看起来是这样的：
使用Matplotlib对Python中的一个三维太阳系进行的模拟现在已经完成。在下一节中，您将添加一个功能，允许您查看 XY -模拟底部的飞机。这有助于可视化太阳系中物体的三维动力学。
在Python的三维太阳系模拟中，为了帮助可视化身体的运动，您可以在动画的“地板”上添加一个2D投影。这个2D投影将显示物体在 XY -飞机。要实现这一点，您需要将另一个绘图添加到显示动画的相同轴上，并且只需在 x -和 y -坐标。你可以锚定 z -与图形底部协调，使2D投影显示在动画的地板上。
您可以首先将一个新参数添加到 __init__() 方法的 SolarSystem 班级：
新参数 projection_2d ，默认为 False ，将允许您在两个可视化选项之间切换。如果 projection_2d 是 False 动画将只显示身体在3D中移动，没有轴和网格，就像你最后看到的结果一样。
让我们开始做一些改变 projection_2d 是 True :
您所做的更改如下：
您还需要在 simple_solar_system.py 打开2D投影：
模拟现在看起来如下：
的二维投影 XY -平面使它更容易跟随轨道物体的路径。
我们将用Python完成另一个三维太阳系的模拟。您将使用已经定义的类来模拟双星系统。创建一个名为 binary_star_system.py 创造两个太阳和两个行星：
在使用Python3时,如果没有相应的函数库可以使用什么命令来 下载
使用 pip 命令行工具在线下载你需要的第三方库。
具体步骤如下：使用pip工具安装软件包的命令是：pipinstallsome到package到name。我们现在下载名字为：requests的第三方库。在命令行窗口中执行下面的命令：pipinstallrequests
这样 requests 第三方库就下载和安装完成了。
Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆 于1990 年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。
二级Python----Python的内置函数及标准库（DAY 8）
python的内置函数（68个）
Python考核31个内置函数，
python内置了很多内置函数、类方法属性及各种模块。当我们想要当我们想要了解某种类型有哪些属性方法以及每种方法该怎么使用时，我们可以使用dir()函数和help()函数在python idle交互式模式下获得我们想要的信息。
• dir()函数获得对象中可用属性的列表
Python中的关键词有哪些？
dir(__builtins__)：查看python内置函数
help(‘keywords‘)：查看python关键词
如微分积分方程的求解程序、访问互联网、获取日期和时间、机器学习算法等。这些程序往往被收入程序库中，构成程序库。
只有经过严格检验的程序才能放在程序库里。检验，就是对程序作充分的测试。通常进行的有正确性测试、精度测试、速度测试、边界条件和出错状态的测试。经过检验的程序不但能保证计算结果的正确性，而且对错误调用也能作出反应。程序库中的程序都是规范化的。所谓规范化有三重含义：①同一库里所有程序的格式是统一的；② 对这些程序的调用方法是相同的；③ 每个程序所需参数的数目、顺序和类型都是严格规定好的。
Python的库包含标准库和第三方库
标准库：程序语言自身拥有的库，可以直接使用。help('modules')
第三方库：第三方者使用该语言提供的程序库。
标准库： turtle 库（必选）、 random 库（必选）、 time 库（可选）。
• turtle 库：图形绘制库
原理如同控制一只海龟，以不同的方向和速度进行位移而得到其运动轨迹。
使用模块的帮助时，需要先将模块导入。
例如：在IDLE中输入import turtle
dir(turtle)
help(turtle.**)
1.画布
画布就是turtle为我们展开用于绘图区域, 我们可以设置它的大小和初始位置。
setup()方法用于初始化画布窗口大小和位置，参数包括画布窗口宽、画布窗口高、窗口在屏幕的水平起始位置和窗口在屏幕的垂直起始位置。
参数:width, height: 输入宽和高为整数时,表示 像素 ;为小数时,表示占据电脑屏幕的比例。(startx,starty):这一坐标表示
矩形窗口左上角顶点的位置,如果为空,则窗口位于屏幕中心:
例如：setup(640,480,300,300)表示在桌面屏幕(300,300)位置开始创建640×480大小的画布窗体。
2、画笔
• color() 用于设置或返回画笔颜色和填充颜色。
例如：color(‘red’)将颜色设为红色，也可用fillcolor()方法设置或返回填充颜色，或用pencolor()方法设置或返回笔触颜色。
python目前三方提供的可用编程模块函数库组件规模有多大
C++，Java和Python是竞争性编程的三种最常见的语言。在本文中，我们将从竞争性编程和面试准备的角度重点介绍最重要的Python模块。

list：动态大小的数组，允许在不关心数组大小的情况下进行插入和删除。它还具有普通数组的优点，例如随机访问和缓存友好性。list也可以用作队列和堆栈。
deque：Dequeue支持在O(1)时间内在两端进行插入和删除。由于它是使用数组实现的，因此它也允许随机访问。我们可以使用dequeue来实现队列和堆栈。关于Deque的示例问题是，访问所有的汽油泵和所有大小为k的子阵列的最大值。
请注意，Python中没有用于队列(Queue)和堆栈(Stack)的模块。我们可以使用列表(list)或双端队列(deque)来实现这些。首选双端队列(deque)实现，尤其是对于队列，因为在列表前面进行插入/删除很慢。
在我们希望具有FIFO项目顺序的情况下，队列(Queue)很有用。问题示例包括：用给定的数字生成数字，流中的第一个非重复字符，树及其变体的级序遍历，图的BFS及其变体。
set和dict：它们都实现了哈希。当我们有键的集合时，我们使用set。当我们有键值对时，我们使用字典(dictionary)。当我们希望快速搜索、插入和删除时非常有用(这三个操作都是O(1))。这是业界使用最多的数据结构之一，也是学术界最低估的数据结构之一。常见的问题有：离散元素的计数、数组项的频率、零和子阵、两个未排序数组的并集、交集等。
heapq：默认情况下实现Min Heap。我们也可以创建最小堆。只要我们希望有效地找到最小或最大元素，就使用它。它用于实现流行的算法，例如Prim算法，Dijkstra最短路径，霍夫曼编码，K个最大元素，购买和合并K个排序数组的最大玩具，流的中位数。
sorted：对列表等序列进行排序。基于排序的示例问题包括：合并重叠间隔，所需的最小平台。第K个最小元素，求给定和的三元组。
bisect：用于二进制搜索。基于二进制搜索的示例问题有：查找第一次出现的索引、计数出现次数、峰值元素、两个排序数组的中值。
注意：与C++ STL和Java集合(Collections)不同。Python标准库包含自平衡BST的实现。在Python中，我们可以使用bisect模块来保留一组排序后的数据。我们还可以使用PyPi模块，例如rbtree(红黑树的实现)和pyavl(AVL树的实现)。
Python怎么生成三维数
1、创建一般的多维数组
import numpy as np
a = np.array([1,2,3], dtype=int) # 创建1*3维数组 array([1,2,3])
type(a) # numpy.ndarray类型
a.shape # 维数信息(3L,)
a.dtype.name # 'int32'
a.size # 元素个数：3
a.itemsize #每个元素所占用的字节数目:4
b=np.array([[1,2,3],[4,5,6]],dtype=int) # 创建2*3维数组 array([[1,2,3],[4,5,6]])
b.shape # 维数信息（2L,3L）
b.size # 元素个数：6
b.itemsize # 每个元素所占用的字节数目:4
c=np.array([[1,2,3],[4,5,6]],dtype='int16') # 创建2*3维数组 array([[1,2,3],[4,5,6]],dtype=int16)
c.shape # 维数信息（2L,3L）
c.size # 元素个数：6
c.itemsize # 每个元素所占用的字节数目:2
c.ndim # 维数
d=np.array([[1,2,3],[4,5,6]],dtype=complex) # 复数二维数组
d.itemsize # 每个元素所占用的字节数目：16
d.dtype.name # 元素类型：'complex128'
2、创建一般的多维数组
import numpy as np
a = np.array([1,2,3], dtype=int) # 创建1*3维数组 array([1,2,3])
type(a) # numpy.ndarray类型
a.shape # 维数信息(3L,)
a.dtype.name # 'int32'
a.size # 元素个数：3
a.itemsize #每个元素所占用的字节数目:4
b=np.array([[1,2,3],[4,5,6]],dtype=int) # 创建2*3维数组 array([[1,2,3],[4,5,6]])
b.shape # 维数信息（2L,3L）
b.size # 元素个数：6
b.itemsize # 每个元素所占用的字节数目:4
c=np.array([[1,2,3],[4,5,6]],dtype='int16') # 创建2*3维数组 array([[1,2,3],[4,5,6]],dtype=int16)
c.shape # 维数信息（2L,3L）
c.size # 元素个数：6
c.itemsize # 每个元素所占用的字节数目:2
c.ndim # 维数
d=np.array([[1,2,3],[4,5,6]],dtype=complex) # 复数二维数组
d.itemsize # 每个元素所占用的字节数目：16
d.dtype.name # 元素类型：'complex128'
3、创建特殊类型的多维数组
a1 = np.zeros((3,4)) # 创建3*4全零二维数组
输出：
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
a1.dtype.name # 元素类型：'float64'
a1.size # 元素个数：12
a1.itemsize # 每个元素所占用的字节个数：8
a2 = np.ones((2,3,4), dtype=np.int16) # 创建2*3*4全1三维数组
a2 = np.ones((2,3,4), dtype='int16') # 创建2*3*4全1三维数组
输出：
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]], dtype=int16)
a3 = np.empty((2,3)) # 创建2*3的未初始化二维数组
输出：（may vary）
array([[ 1., 2., 3.],
[ 4., 5., 6.]])
a4 = np.arange(10,30,5) # 初始值10，结束值：30（不包含），步长：5
输出：array([10, 15, 20, 25])
a5 = np.arange(0,2,0.3) # 初始值0，结束值：2（不包含），步长：0.2
输出：array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
from numpy import pi
np.linspace(0, 2, 9) # 初始值0，结束值：2（包含），元素个数：9
输出：
array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
x = np.linspace(0, 2*pi, 9)
输出：
array([ 0. , 0.78539816, 1.57079633, 2.35619449, 3.14159265,
3.92699082, 4.71238898, 5.49778714, 6.28318531])
a = np.arange(6)
输出：
array([0, 1, 2, 3, 4, 5])
b = np.arange(12).reshape(4,3)
输出：
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
c = np.arange(24).reshape(2,3,4)
输出：
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
使用numpy.set_printoptions可以设置numpy变量的打印格式
在ipython环境下，使用help(numpy.set_printoptions)查询使用帮助和示例
4、多维数组的基本操作
加法和减法操作要求操作双方的维数信息一致，均为M*N为数组方可正确执行操作。
a = np.arange(4)
输出：
array([0, 1, 2, 3])
b = a**2
输出：
array([0, 1, 4, 9])
c = 10*np.sin(a)
输出：
array([ 0. , 8.41470985, 9.09297427, 1.41120008])
n 35
输出：
array([ True, True, True, True], dtype=bool)
A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
C = A * B # 元素点乘
输出：
array([[2, 0],
[0, 4]])
D = A.dot(B) # 矩阵乘法
输出：
array([[5, 4],
[3, 4]])
E = np.dot(A,B) # 矩阵乘法
输出：
array([[5, 4],
[3, 4]])
多维数组操作过程中的类型转换
When operating with arrays of different types, the type of the
resulting array corresponds to the more general or precise one (a
behavior known as upcasting)
即操作不同类型的多维数组时，结果自动转换为精度更高类型的数组，即upcasting
数组索引、切片和迭代
a = np.ones((2,3),dtype=int) # int32
b = np.random.random((2,3)) # float64
b += a # 正确
a += b # 错误
a = np.ones(3,dtype=np.int32)
b = np.linspace(0,pi,3)
c = a + b
d = np.exp(c*1j)
输出：
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
-0.54030231-0.84147098j])
d.dtype.name
输出：
'complex128'
多维数组的一元操作，如求和、求最小值、最大值等
a = np.random.random((2,3))
a.sum()
a.min()
a.max()
b = np.arange(12).reshape(3,4)
输出：
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
b.sum(axis=0) # 按列求和
输出：
array([12, 15, 18, 21])
b.sum(axis=1) # 按行求和
输出：
array([ 6, 22, 38])
b.cumsum(axis=0) # 按列进行元素累加
输出：
array([[ 0, 1, 2, 3],
[ 4, 6, 8, 10],
[12, 15, 18, 21]])
b.cumsum(axis=1) # 按行进行元素累加
输出：
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
universal functions
B = np.arange(3)
np.exp(B)
np.sqrt(B)
C = np.array([2.,-1.,4.])
np.add(B,C)
其他的ufunc函数包括：
all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor,inner, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var,vdot, vectorize, where
5. 数组索引、切片和迭代
a = np.arange(10)**3
a[2]
a[2:5]
a[::-1] # 逆序输出
for i in a:
print (i**(1/3.))
def f(x,y):
return 10*x+y
b = np.fromfunction(f,(5,4),dtype=int)
b[2,3]
b[0:5,1]
b[:,1]
b[1:3,:]
b[-1]
c = np.array([[[0,1,2],[10,11,12]],[[100,101,102],[110,111,112]]])
输出：
array([[[ 0, 1, 2],
[ 10, 11, 12]],
[[100, 101, 102],
[110, 111, 112]]])
c.shape
输出：
(2L, 2L, 3L)
c[0,...]
c[0,:,:]
输出：
array([[ 0, 1, 2],
[10, 11, 12]])
c[:,:,2]
c[...,2]
输出：
array([[ 2, 12],
[102, 112]])
for row in c:
print(row)
for element in c.flat:
print(element)
a = np.floor(10*np.random.random((3,4)))
输出：
array([[ 3., 9., 8., 4.],
[ 2., 1., 4., 6.],
[ 0., 6., 0., 2.]])
a.ravel()
输出：
array([ 3., 9., 8., ..., 6., 0., 2.])
a.reshape(6,2)
输出：
array([[ 3., 9.],
[ 8., 4.],
[ 2., 1.],
[ 4., 6.],
[ 0., 6.],
[ 0., 2.]])
a.T
输出：
array([[ 3., 2., 0.],
[ 9., 1., 6.],
[ 8., 4., 0.],
[ 4., 6., 2.]])
a.T.shape
输出：
(4L, 3L)
a.resize((2,6))
输出：
array([[ 3., 9., 8., 4., 2., 1.],
[ 4., 6., 0., 6., 0., 2.]])
a.shape
输出：
(2L, 6L)
a.reshape(3,-1)
输出：
array([[ 3., 9., 8., 4.],
[ 2., 1., 4., 6.],
[ 0., 6., 0., 2.]])
详查以下函数：
ndarray.shape, reshape, resize, ravel
6. 组合不同的多维数组
a = np.floor(10*np.random.random((2,2)))
输出：
array([[ 5., 2.],
[ 6., 2.]])
b = np.floor(10*np.random.random((2,2)))
输出：
array([[ 0., 2.],
[ 4., 1.]])
np.vstack((a,b))
输出：
array([[ 5., 2.],
[ 6., 2.],
[ 0., 2.],
[ 4., 1.]])
np.hstack((a,b))
输出：
array([[ 5., 2., 0., 2.],
[ 6., 2., 4., 1.]])
from numpy import newaxis
np.column_stack((a,b))
输出：
array([[ 5., 2., 0., 2.],
[ 6., 2., 4., 1.]])
a = np.array([4.,2.])
b = np.array([2.,8.])
a[:,newaxis]
输出：
array([[ 4.],
[ 2.]])
b[:,newaxis]
输出：
array([[ 2.],
[ 8.]])
np.column_stack((a[:,newaxis],b[:,newaxis]))
输出：
array([[ 4., 2.],
[ 2., 8.]])
np.vstack((a[:,newaxis],b[:,newaxis]))
输出：
array([[ 4.],
[ 2.],
[ 2.],
[ 8.]])
np.r_[1:4,0,4]
输出：
array([1, 2, 3, 0, 4])
np.c_[np.array([[1,2,3]]),0,0,0,np.array([[4,5,6]])]
输出：
array([[1, 2, 3, 0, 0, 0, 4, 5, 6]])
详细使用请查询以下函数：
hstack, vstack, column_stack, concatenate, c_, r_
7. 将较大的多维数组分割成较小的多维数组
a = np.floor(10*np.random.random((2,12)))
输出：
array([[ 9., 7., 9., ..., 3., 2., 4.],
[ 5., 3., 3., ..., 9., 7., 7.]])
np.hsplit(a,3)
输出：
[array([[ 9., 7., 9., 6.],
[ 5., 3., 3., 1.]]), array([[ 7., 2., 1., 6.],
[ 7., 5., 0., 2.]]), array([[ 9., 3., 2., 4.],
[ 3., 9., 7., 7.]])]
np.hsplit(a,(3,4))
输出：
[array([[ 9., 7., 9.],
[ 5., 3., 3.]]), array([[ 6.],
[ 1.]]), array([[ 7., 2., 1., ..., 3., 2., 4.],
[ 7., 5., 0., ..., 9., 7., 7.]])]
实现类似功能的函数包括：
hsplit,vsplit,array_split
8. 多维数组的复制操作
a = np.arange(12)
输出：
array([ 0, 1, 2, ..., 9, 10, 11])
not copy at all
b = a
b is a # True
b.shape = 3,4
a.shape # (3L,4L)
def f(x) # Python passes mutable objects as references, so function calls make no copy.
print(id(x)) # id是python对象的唯一标识符
id(a) # 111833936L
id(b) # 111833936L
f(a) # 111833936L
浅复制
c = a.view()
c is a # False
c.base is a # True
c.flags.owndata # False
c.shape = 2,6
a.shape # (3L,4L)
c[0,4] = 1234
print(a)
输出：
array([[ 0, 1, 2, 3],
[1234, 5, 6, 7],
[ 8, 9, 10, 11]])
s = a[:,1:3]
s[:] = 10
print(a)
输出：
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
深复制
d = a.copy()
d is a # False
d.base is a # False
d[0,0] = 9999
print(a)
输出：
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
numpy基本函数和方法一览
Array Creation
arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r, zeros,zeros_like
Conversions
ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat
Manipulations
array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel, repeat, reshape, resize,squeeze, swapaxes, take, transpose, vsplit, vstack
Questionsall, any, nonzero, where
Ordering
argmax, argmin, argsort, max, min, ptp, searchsorted, sort
Operations
choose, compress, cumprod, cumsum, inner, ndarray.fill, imag, prod, put, putmask, real, sum
Basic Statistics
cov, mean, std, var
Basic Linear Algebra
cross, dot, outer, linalg.svd, vdot
完整的函数和方法一览表链接：
分享名称：python三维函数库 python三维数据
当前路径：http://pwwzsj.com/article/hjopsj.html
