python基础之Numpy库中array用法总结-6ren

python基础之Numpy库中array用法总结

转载作者：qq735679552 更新时间：2022-09-27 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章python基础之Numpy库中array用法总结由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

前言

Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数.

NumPy数组是一个多维数组对象，称为ndarray。数组的下标从0开始,同一个NumPy数组中所有元素的类型必须是相同的.

 
    ? 
   
         >>>  
         import 
         numpy as np

为什么要用numpy

Python中提供了list容器，可以当作数组使用。但列表中的元素可以是任何对象，因此列表中保存的是对象的指针，这样一来，为了保存一个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说，这种结构显然不够高效.

Python虽然也提供了array模块，但其只支持一维数组，不支持多维数组(在TensorFlow里面偏向于矩阵理解)，也没有各种运算函数。因而不适合数值运算.

NumPy的出现弥补了这些不足.

数组的创建

使用numpy.array方法将tuple和list, array, 或者其他的序列模式的数据转创建为 ndarray, 默认创建一个新的 ndarray. 。

 
    ? 
   
 
     
       
       
         >>> np.array([ 
         1 
         , 
         2 
         , 
         3 
         , 
         4 
         ])  
        
 
         [ 
         1 
         2 
         3 
         4 
         ] 
        

            
        
 
         >>> b  
         = 
         array( [ ( 
         1.5 
         , 
         2 
         , 
         3 
         ),  
        
 
                           
         ( 
         4 
         , 
         5 
         , 
         6 
         )  ]  )　　  
        
 
         array([[  
         1.5 
         ,   
         2. 
         ,   
         3. 
         ],   
        
 
         　　　  [  
         4. 
         ,   
         5. 
         ,   
         6. 
         ]])   
        

            
        
 
         >>> c  
         = 
         array( [ [ 
         1 
         , 
         2 
         ], [ 
         3 
         , 
         4 
         ] ], dtype 
         = 
         complex 
         )   
        
 
         #指定数组中元素的类型 
        
 
         >>> c   
        
 
              
         array([[  
         1. 
         + 
         0.j 
         ,   
         2. 
         + 
         0.j 
         ],   
        
 
         　　　    [  
         3. 
         + 
         0.j 
         ,   
         4. 
         + 
         0.j 
         ]]) 
        
 
     
 
   

生成均匀分布的array：

arange（最小值，最大值，步长）（左闭右开） : 创建等差数列。

linspace（最小值，最大值，元素数量）。

logspace(开始值, 终值, 元素个数): 创建等比数列。

 
    ? 
   
 
     
       
       
         >>> np.arange( 
         15 
         ) 
        
 
         [  
         0  
         1  
         2  
         3  
         4  
         5  
         6  
         7  
         8  
         9 
         10 
         11 
         12 
         13 
         14 
         ] 
        

            
        
 
         >>> np.arange( 
         15 
         ).reshape( 
         3 
         , 
         5 
         ) 
        
 
         [[  
         0  
         1  
         2  
         3  
         4 
         ] 
        
 
           
         [  
         5  
         6  
         7  
         8  
         9 
         ] 
        
 
           
         [ 
         10 
         11 
         12 
         13 
         14 
         ]] 
        

            
        
 
         >>> np.arange(  
         0 
         ,  
         2 
         ,  
         0.3 
         )         
        
 
         array([  
         0. 
         ,   
         0.3 
         ,   
         0.6 
         ,   
         0.9 
         ,   
         1.2 
         ,   
         1.5 
         ,   
         1.8 
         ]) 
        

            
        
 
         >>> np.linspace( 
         1 
         , 
         3 
         , 
         9 
         ) 
        
 
         [  
         1.    
         1.25  
         1.5   
         1.75  
         2.    
         2.25  
         2.5   
         2.75  
         3.  
         ] 
        
 
     
 
   

生成特殊数组

np.ones: 创建一个数组, 其中的元素全为 1 。

np.zeros: 创建元素全为 0 的数组, 类似 np.ones 。

np.empty创建一个内容随机并且依赖与内存状态的数组.

np.eye: 创建一个对角线为 1 其他为 0 的矩阵. 。

np.identity: 创建一个主对角线为 1 其他为 0 的方阵. 。

 
    ? 
   
 
     
       
       
         >>> np.zeros(( 
         3 
         , 
         4 
         )) 
        
 
         [[  
         0.  
         0.  
         0.  
         0. 
         ] 
        
 
           
         [  
         0.  
         0.  
         0.  
         0. 
         ] 
        
 
           
         [  
         0.  
         0.  
         0.  
         0. 
         ]] 
        

            
        
 
         >>> np.ones(( 
         3 
         , 
         4 
         )) 
        
 
         [[  
         1.  
         1.  
         1.  
         1. 
         ] 
        
 
           
         [  
         1.  
         1.  
         1.  
         1. 
         ] 
        
 
           
         [  
         1.  
         1.  
         1.  
         1. 
         ]] 
        

            
        
 
         >>> np.eye( 
         3 
         ) 
        
 
         [[  
         1.  
         0.  
         0. 
         ] 
        
 
           
         [  
         0.  
         1.  
         0. 
         ] 
        
 
           
         [  
         0.  
         0.  
         1. 
         ]] 
        
 
     
 
   

获取数组的属性

 
    ? 
   
         >>> a  
         = 
         np.zeros(( 
         2 
         , 
         2 
         , 
         2 
         )) 
        
         >>> a.ndim    
         #数组的维数 
        
         3 
        
         >>> a.shape   
         #数组每一维的大小 
        
         ( 
         2 
         ,  
         2 
         ,  
         2 
         ) 
        
         >>> a.size    
         #数组全部元素的数量  
        
         8 
        
         >>> a.dtype   
         #数组中元素的类型 
        
         float64 
        
         >>>  
         print 
         a.itemsize   
         #每个元素所占的字节数 
        
         8

数组索引，切片，赋值

‘…'符号表示将所有未指定索引的维度均赋为 ‘：' 。

‘：'在python中表示该维所有元素。

 
    ? 
   
 
     
       
       
         >>> a  
         = 
         np.array( [[ 
         2 
         , 
         3 
         , 
         4 
         ],[ 
         5 
         , 
         6 
         , 
         7 
         ]] ) 
        
 
         >>> a 
        
 
         [[ 
         2 
         3 
         4 
         ] 
        
 
           
         [ 
         5 
         6 
         7 
         ]] 
        
 
         >>> a[ 
         1 
         , 
         2 
         ] 
        
 
         7 
        
 
         >>> a[ 
         1 
         ,:] 
        
 
         [ 
         5 
         6 
         7 
         ] 
        
 
         >>>  
         print 
         a[ 
         1 
         , 
         1 
         : 
         2 
         ] 
        
 
         [ 
         6 
         ] 
        
 
         >>> a[ 
         1 
         ,:]  
         = 
         [ 
         8 
         , 
         9 
         , 
         10 
         ] 
        
 
         >>> a 
        
 
         [[  
         2  
         3  
         4 
         ] 
        
 
           
         [  
         8  
         9 
         10 
         ]] 
        
 
         >>> c[ 
         1 
         ,...]                                    
         # same as c[1,:,:] or c[1] 
        
 
         array([[ 
         100 
         ,  
         101 
         ,  
         102 
         ], 
        
 
                 
         [ 
         110 
         ,  
         112 
         ,  
         113 
         ]]) 
        
 
         >>> c[..., 
         2 
         ]                                    
         # same as c[:,:,2] 
        
 
         array([[   
         2 
         ,   
         13 
         ], 
        
 
                 
         [ 
         102 
         ,  
         113 
         ]]) 
        
 
         >>>  
         def 
         f(x,y): 
        
 
         ...      
         return 
         10 
         * 
         x 
         + 
         y 
        
 
         ... 
        
 
         >>> b  
         = 
         np.fromfunction(f,( 
         5 
         , 
         4 
         ),dtype 
         = 
         int 
         )     
         # 
        
 
         >>> b 
        
 
         array([[  
         0 
         ,   
         1 
         ,   
         2 
         ,   
         3 
         ], 
        
 
                 
         [ 
         10 
         ,  
         11 
         ,  
         12 
         ,  
         13 
         ], 
        
 
                 
         [ 
         20 
         ,  
         21 
         ,  
         22 
         ,  
         23 
         ], 
        
 
                 
         [ 
         30 
         ,  
         31 
         ,  
         32 
         ,  
         33 
         ], 
        
 
                 
         [ 
         40 
         ,  
         41 
         ,  
         42 
         ,  
         43 
         ]]) 
        
 
     
 
   

数组操作

 
    ? 
   
 
     
       
       
         >>>  
         print 
         a >  
         2 
        
 
         [[ 
         False 
         False 
         ] 
        
 
           
         [ 
         False 
         False 
         ]] 
        
 
         >>>  
         print 
         a 
         + 
         b              
         #数组加，对应位置相加 
        
 
         [[  
         2.  
         1. 
         ] 
        
 
           
         [  
         1.  
         2. 
         ]] 
        
 
         >>>  
         print 
         a 
         - 
         b              
         #数组减，对应位置相减 
        
 
         [[  
         0.  
         1. 
         ] 
        
 
           
         [  
         1.  
         0. 
         ]] 
        
 
         >>>  
         print 
         b 
         * 
         2             
         #数组与数值相乘，对应位置乘 
        
 
         [[  
         2.  
         0. 
         ] 
        
 
           
         [  
         0.  
         2. 
         ]] 
        
 
         >>>  
         print 
         (a 
         * 
         2 
         ) 
         * 
         (b 
         * 
         2 
         )      
         #数组与数组相乘，按位置一对一相乘 
        
 
         [[  
         4.  
         0. 
         ] 
        
 
           
         [  
         0.  
         4. 
         ]] 
        
 
         >>>  
         print 
         b 
         / 
         (a 
         * 
         2 
         )           
         #数组与数组相除，按位置一对一相除 
        
 
         [[  
         0.5  
         0. 
         ] 
        
 
           
         [  
         0.   
         0.5 
         ]] 
        
 
         >>>  
         print 
         a.dot(b)                     
         # matrix product，矩阵乘 
        
 
         >>> np.dot(a,a)                        
         #矩阵乘法 
        
 
         array([[  
         2. 
         ,   
         2. 
         ], 
        
 
                 
         [  
         2. 
         ,   
         2. 
         ]]) 
        
 
         >>>  
         print 
         (a 
         * 
         2 
         ) 
         * 
         * 
         4 
        
 
         [[  
         16.  
         16. 
         ] 
        
 
           
         [  
         16.  
         16. 
         ]] 
        
 
         >>> b  
         = 
         a               
         #浅拷贝 
        
 
         >>> b  
         is 
         a 
        
 
         True 
        
 
         >>> c  
         = 
         a.copy()        
         #深拷贝 
        
 
         >>> c  
         is 
         a 
        
 
         False 
        
 
     
 
   

内置函数（min,max,sum)，同时可以使用axis指定对哪一维进行操作:

 
    ? 
   
         >>> a. 
         sum 
         () 
        
         4.0 
        
         >>> a. 
         sum 
         (axis 
         = 
         0 
         )     
         #计算每一列（二维数组中类似于矩阵的列）的和 
        
         array([  
         2. 
         ,   
         2. 
         ]) 
        
         >>> a. 
         min 
         ()           
         #数组最小值 
        
         1.0 
        
         >>> a. 
         max 
         ()           
         #数组最大值 
        
         1.0

使用numpy下的方法:

 
    ? 
   
         >>> np.sin(a) 
        
         array([[  
         0.84147098 
         ,   
         0.84147098 
         ], 
        
         [  
         0.84147098 
         ,   
         0.84147098 
         ]]) 
        
         >>> np. 
         max 
         (a) 
        
         1.0 
        
         >>> np.floor(a)   
        
         array([[  
         1. 
         ,   
         1. 
         ], 
        
         [  
         1. 
         ,   
         1. 
         ]]) 
        
         >>> np.exp(a)                
         #e^x 
        
         array([[  
         2.71828183 
         ,   
         2.71828183 
         ], 
        
         [  
         2.71828183 
         ,   
         2.71828183 
         ]]) 
        
         >>>  
         print 
         np.vstack((a,b))    
         #合并数组 
        
         [[  
         1.  
         1. 
         ]  
        
         [  
         1.  
         1. 
         ] 
        
         [  
         1.  
         0. 
         ] 
        
         [  
         0.  
         1. 
         ]] 
        
         >>>  
         print 
         np.hstack((a,b))    
         #合并数组 
        
         [[  
         1.  
         1.  
         1.  
         0. 
         ] 
        
         [  
         1.  
         1.  
         0.  
         1. 
         ]] 
        
         >>>  
         print 
         a.transpose()        
         #转置

numpy.linalg模块中有很多关于矩阵运算的方法:

 
    ? 
   
         >>>  
         import 
         numpy.linalg as nplg

NumPy中的基本数据类型。

名称	描述
bool	用一个字节存储的布尔类型（True或False）
inti	由所在平台决定其大小的整数（一般为int32或int64）
int8/16/32/64	整数，1/2/4/8个字节大小
uint8/16/32/64	无符号整数
float16/32/64	半/单/双精度浮点数，16/32/64位，指数、精度也不同
complex64/128	复数，分别用两个32/64位浮点数表示实部和虚部

输出数组

当输出一个数组时，NumPy以特定的布局用类似嵌套列表的形式显示:

第一行从左到右输出
每个切片通过一个空行与下一个隔开
一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表。
如果一个数组太长，则NumPy自动省略中间部分而只打印两端的数据：

总结

到此这篇关于python基础之Numpy库中array用法的文章就介绍到这了,更多相关python Numpy中array用法内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！。

原文链接：https://blog.csdn.net/github_36669230/article/details/78038756 。

最后此篇关于python基础之Numpy库中array用法总结的文章就讲到这里了,如果你想了解更多关于python基础之Numpy库中array用法总结的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： apache rewrite规则实现白名单

文章推荐：在varnish、squid、apache、nginx中选出一个更好的缓存服务器

文章推荐： ubuntu下搭建php开发环境（nginx+(cgi)php5fpm+memcached+xdebug）

文章推荐： Python使用Appium在移动端抓取微博数据的实现

【网络流】总结
1、定义设 \(u\) 和 \(v\) 为一张图上的任意两个节点。令 \(c(u, v)\) 为它们之间的边的容量， \(f(u, v)\) 为它们之间的流量，则需要满足以
linux下判断文件和目录是否存在的方法(总结)
1、前言工作中涉及到文件系统，有时候需要判断文件和目录是否存在。我结合apue第四章文件和目录，总结一下如何正确判断文件和目录是否存在，方便以后查询。 2、stat系列函数 stat函数用来
c语言数据结构之并查集总结
并查集(Union-Find Set)：一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。注意：并查集不能将在同一组的元素拆
Mybatis常见注解有哪些(总结)
当下，注解非常流行，以前很长篇的代码，现在基本上一个注解就能搞定。那，在Mybatis中又有哪些注解呢？ Mybatis中的注解基本上都在org.apache.ibatis.annotat
指针操作数组的两种方法(总结)
指针操作数组，方法一是p+index，方法二是p[index]，第二种方法跟数组访问方法是一样的。数组引用返回的是数组的第一个元素的指针地址。可以将指针指向数组的任意元素，然后从那里开始访问
php安全配置记录和常见错误梳理(总结)
通常部署完php环境后会进行一些安全设置，除了熟悉各种php漏洞外，还可以通过配置php.ini来加固PHP的运行环境，PHP官方也曾经多次修改php.ini的默认设置。下面对php.ini中一
PHP检测数据类型的几种方法(总结)
在JavaScript中，使用typeof可以检测基本数据类型，使用instanceof可以检测引用数据类型。在PHP中，也有检测数据类型的方法，具体如下： 1、输出变量的数据类型（gettype
iOS把图片缓存到本地的几种方法(总结)
把图片缓存到本地，在很多场景都会用到，如果只是存储文件信息，那建一个plist文件，或者数据库就能很方便的解决问题，但是如果存储图片到沙盒就没那么方便了。这里简单介绍两种保存图片到沙盒的方法。
Docker容器使用jenkins部署web项目(总结)
（1）需要安装docker容器，在docker容器内安装jenkins，gogs，tomcat。新建maven项目，添加findbugs plugin。使用docker
基于并发服务器几种实现方法(总结)
今天主题是实现并发服务器，实现方法有多种版本，先从简单的单进程代码实现到多进程，多线程的实现，最终引入一些高级模块来实现并发TCP服务器。说到TCP，想起吐槽大会有个段子提到三次握手，也只有程序
超实用的Java快捷键(总结)
如下所示： Ctrl+1或F2快速修复 Ctrl+D快捷删除行 Shift+Enter 快速切换到下一行，在本行的任何位置都可 Ctrl+F11快速运行代码 Alt+上下键快速移动行（可
浅谈JSP与Servlet传值及对比(总结)
JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。 JSP编译后是”类servlet”。 Servlet和JSP最主要的不同点在于，Servlet的应用逻辑
Java中实现多线程关键词整理(总结)
Java中的Runable,Callable,Future,FutureTask,ExecutorService,Excetor,Excutors,ThreadPoolExcetor在这里对这些关键
读取Java文件到byte数组的三种方法(总结)
读取Java文件到byte数组的三种方法(总结) ? 1
java实现二叉树的创建及5种遍历方法(总结)
用java实现的数组创建二叉树以及递归先序遍历，递归中序遍历，递归后序遍历，非递归前序遍历，非递归中序遍历，非递归后序遍历，深度优先遍历，广度优先遍历8种遍历方式：
Mysql字符串处理函数详细介绍、总结
1、简明总结 ASCII(char)　　　　　　　　返回字符的ASCII码值 BIT_LENGTH(str)　　　　　　返回字符串的比特长度 CONCAT(s1,s2…,sn)　　　　
十大java应用服务器(webserver)总结
java应用服务器(web server)，是指运行java程序的web应用服务器软件，不包括nginx、Apache等通用web服务器软件。一、Tomcat Tomcat是Apache 软件基
精通Java事务编程(9)-总结
事务作为抽象层，允许应用忽略DB 内部一些复杂并发问题和某些硬件、软件故障，简化应用层的处理逻辑：事务中止（transaction abort），而应用仅需重试。对复杂访问模式，事务可大大减少需要考虑
10、DTD 总结
我们在本教程学习了如何描述 XML 文档的结构我们学习到了如何使用 DTD 来定义一个 XML 文档的合法元素，以及如何在我们的 XML 内部或者作为一个外部引用来声明 DTD 我们学习了如何为
08、XPath 总结
在这个XPath 基础教程中我们讲解了如何在 XML 文档中查找信息我们可以使用 XPath 的元素和属性在 XML 文档中进行导航我们也学习了如何使用 XPath 中内建的某些标准函数如

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城