Numpy基础知识

最新推荐文章于 2024-09-07 21:59:06 发布
最新推荐文章于 2024-09-07 21:59:06 发布
阅读量3.6k 收藏 5
点赞数
分类专栏： Numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38669138/article/details/79371333
版权
Numpy基础（个人微信公众号：“我将在南极找寻你”）

1Numpy数组对象以及创建方式

ndarray是一个多维数组对象，由“实际数据”+“元数据”组成

创建一维数组

  1. >>> a=np.arange(5)

  2. >>> a.dtype

  3. dtype('int32')

  4. >>> a

  5. array([0, 1, 2, 3, 4])

  6. >>> a.shape

  7. (5L,)

创建多维数组

  1. >>> c=np.array([np.arange(4),np.arange(4),np.arange(4)])

  2. >>> c

  3. array([[0, 1, 2, 3],

  4.       [0, 1, 2, 3],

  5.       [0, 1, 2, 3]])

  6. >>> c.shape

  7. (3L, 4L)

2选取数组元素

首先创建一个2*2数组：

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

  2. >>> a

  3. array([[1, 2],

  4.       [3, 4]])

开始选取：

  1. >>> a[0,0]

  2. 1

  3. >>> a[0,1]

  4. 2

3指定Numpy数据类型

  1. >>> x=np.arange(5,dtype=int)

  2. >>> x

  3. array([0, 1, 2, 3, 4])

  4. >>> x.dtype

  5. dtype('int32')

4索引与切片

一维数组的索引与切片

 

  1. >>> r=np.arange(10)
  2. >>> r
  3. array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  4. >>> r[0:4]
  5. array([0, 1, 2, 3])
  6. >>> r[:4]
  7. array([0, 1, 2, 3])
  8. >>> r[3:7]
  9. array([3, 4, 5, 6])
  10. >>> r[:7:2]
  11. array([0, 2, 4, 6])
  12. >>> r[::-1]
  13. array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
 

 
 
多维数组的索引与切片
 

 

首先创建一个数组并改变其维度为3维
 

  1. >>> x.shape
  2. (24L,)
  3. >>> x=np.arange(24).reshape(2,3,4)
  4. >>> x.shape
  5. (2L, 3L, 4L)
  6. >>> x
  7. array([[[ 0,  1,  2,  3],
  8.         [ 4,  5,  6,  7],
  9.         [ 8,  9, 10, 11]],
  10.        [[12, 13, 14, 15],
  11.         [16, 17, 18, 19],
  12.         [20, 21, 22, 23]]])
 

选取特定元素：
 

 

  1. >>> x[0,0,0]
  2. 0
  3. >>> x[0,1,1]
  4. 5
 

切片：
 

  1. >>> x[:,0,0]
  2. array([ 0, 12])
  3. >>> x[0]
  4. array([[ 0,  1,  2,  3],
  5.        [ 4,  5,  6,  7],
  6.        [ 8,  9, 10, 11]])
  7. >>> x[0,:,:]
  8. array([[ 0,  1,  2,  3],
  9.        [ 4,  5,  6,  7],
  10.        [ 8,  9, 10, 11]])
  11. >>> x[0,...]
  12. array([[ 0,  1,  2,  3],
  13.        [ 4,  5,  6,  7],
  14.        [ 8,  9, 10, 11]])
  15. >>> x[0,1]
  16. array([4, 5, 6, 7])
 

间隔选取
 

 

  1. >>> x[0,1]
  2. array([4, 5, 6, 7])
  3. >>> x[0,0,::2]
  4. array([0, 2])
  5. >>> x[0,1,::2]
  6. array([4, 6])
  7. >>> x[0,1,::1]
  8. array([4, 5, 6, 7])
  9. >>> x[0,1]
  10. array([4, 5, 6, 7])
  11. >>> x[0,::2,-1]
  12. array([ 3, 11])
  13. >>> x[0,::-1,-1]
  14. array([11,  7,  3])
 

：：2代表间隔为2（含第一个元素）
 

上下翻转：
 

  1. >>> x[::-1]
  2. array([[[12, 13, 14, 15],
  3.         [16, 17, 18, 19],
  4.         [20, 21, 22, 23]],
  5.        [[ 0,  1,  2,  3],
  6.         [ 4,  5,  6,  7],
  7.         [ 8,  9, 10, 11]]])
 

其实就是把列逆序重排了一下
 


 

5改变数组维度
 

（1）ravel：将ndarray展平成一维数组
 

 

  1. >>> x
  2. array([[[ 0,  1,  2,  3],
  3.         [ 4,  5,  6,  7],
  4.         [ 8,  9, 10, 11]],
  5.        [[12, 13, 14, 15],
  6.         [16, 17, 18, 19],
  7.         [20, 21, 22, 23]]])
  8. >>> x.ravel
  9. <built-in method ravel of numpy.ndarray object at 0x0000000003497490>
  10. >>> x.ravel()
  11. array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
  12.        17, 18, 19, 20, 21, 22, 23])
 

（2）flatten:作用与ravel类似，但是它会请求分配内存来保存结果
 

（3）用tuple来设置维度，功能同reshape：
 

  1. >>> x.shape
  2. (2L, 3L, 4L)
  3. >>> x.shape=(3,8)
  4. >>> x.shape
  5. (3L, 8L)
  6. >>> x
  7. array([[ 0,  1,  2,  3,  4,  5,  6,  7],
  8.        [ 8,  9, 10, 11, 12, 13, 14, 15],
  9.        [16, 17, 18, 19, 20, 21, 22, 23]])
 

（4）transpose：转置
 

  1. >>> x
  2. array([[ 0,  1,  2,  3,  4,  5,  6,  7],
  3.        [ 8,  9, 10, 11, 12, 13, 14, 15],
  4.        [16, 17, 18, 19, 20, 21, 22, 23]])
  5. >>> x.transpose()
  6. array([[ 0,  8, 16],
  7.        [ 1,  9, 17],
  8.        [ 2, 10, 18],
  9.        [ 3, 11, 19],
  10.        [ 4, 12, 20],
  11.        [ 5, 13, 21],
  12.        [ 6, 14, 22],
  13.        [ 7, 15, 23]])
 

（5）resize：同reshape，但会直接修改所操作的数组
 

 

  1. >>> x
  2. array([[ 0,  1,  2],
  3.        [ 3,  4,  5],
  4.        [ 6,  7,  8],
  5.        [ 9, 10, 11],
  6.        [12, 13, 14],
  7.        [15, 16, 17],
  8.        [18, 19, 20],
  9.        [21, 22, 23]])
  10. >>> x.resize(6,4)
  11. >>> x
  12. array([[ 0,  1,  2,  3],
  13.        [ 4,  5,  6,  7],
  14.        [ 8,  9, 10, 11],
  15.        [12, 13, 14, 15],
  16.        [16, 17, 18, 19],
  17.        [20, 21, 22, 23]])
  18. >>> x.shape
  19. (6L, 4L)
 

6数组的组合
 

首先，我们来创建一个数组 ：
 

  1. >>> a=np.array(np.arange(9)).reshape(3,3)
  2. >>> a
  3. array([[0, 1, 2],
  4.        [3, 4, 5],
  5.        [6, 7, 8]])
 

或者
 

  1. >>> a=np.arange(9).reshape(3,3)
  2. >>> a
  3. array([[0, 1, 2],
  4.        [3, 4, 5],
  5.        [6, 7, 8]])
 

两者都可以生成，whatever，我们已经创建完了数组a，下面来创建数组b
 

  1. >>> b=2*a
  2. >>> b
  3. array([[ 0,  2,  4],
  4.        [ 6,  8, 10],
  5.        [12, 14, 16]])
 

（1）水平组合
 

hstack
 

  1. >>> np.hstack((a,b))
  2. array([[ 0,  1,  2,  0,  2,  4],
  3.        [ 3,  4,  5,  6,  8, 10],
  4.        [ 6,  7,  8, 12, 14, 16]])
 

concatenate
 

 

  1. >>> np.concatenate((a,b),axis=1)
  2. array([[ 0,  1,  2,  0,  2,  4],
  3.        [ 3,  4,  5,  6,  8, 10],
  4.        [ 6,  7,  8, 12, 14, 16]])
 

（2）垂直组合
 

vstack
 

  1. >>> np.vstack((a,b))
  2. array([[ 0,  1,  2],
  3.        [ 3,  4,  5],
  4.        [ 6,  7,  8],
  5.        [ 0,  2,  4],
  6.        [ 6,  8, 10],
  7.        [12, 14, 16]])
 

concatenate
 

  1. >>> np.concatenate((a,b),axis=0)
  2. array([[ 0,  1,  2],
  3.        [ 3,  4,  5],
  4.        [ 6,  7,  8],
  5.        [ 0,  2,  4],
  6.        [ 6,  8, 10],
  7.        [12, 14, 16]])
 

一般来说，axis=0在行（竖向）方向上处理，axis=1在列（横向）方向上处理
 

（3）深度组合
 

 

  1. >>> np.dstack((a,b))
  2. array([[[ 0,  0],
  3.         [ 1,  2],
  4.         [ 2,  4]],
  5.        [[ 3,  6],
  6.         [ 4,  8],
  7.         [ 5, 10]],
  8.        [[ 6, 12],
  9.         [ 7, 14],
  10.         [ 8, 16]]])
  11. >>> np.dstack((a,b)).shape
  12. (3L, 3L, 2L)
 

所谓深度组合，就是将一系列数组沿着纵轴方向进行层叠组合
 

（4）列组合
 

column_stack
 

 

  1. >>> oned=np.arange(2)
  2. >>> oned
  3. array([0, 1])
  4. >>> twice_oned=2*oned
  5. >>> twice_oned
  6. array([0, 2])
  7. >>> np.column_stack((oned,twice_oned))
  8. array([[0, 0],
  9.        [1, 2]])
 

所以对于二维数组，column_stack与hstack效果相同
 

（5）行组合
 

row_stack
 

  1. >>> np.row_stack((oned,twice_oned))
  2. array([[0, 1],
  3.        [0, 2]])
 

所以对于二维数组，row_stack与vstack效果相同
 

7数组的分割
 

（1）水平分割
 

hsplit
 

  1. >>> np.hsplit(a,3)
  2. [array([[0],
  3.        [3],
  4.        [6]]), array([[1],
  5.        [4],
  6.        [7]]), array([[2],
  7.        [5],
  8.        [8]])]
 

分割成了3个子数组，他们组成了一个列表
 

>>> len(np.hsplit(a,3))
 

3
 

>>> type(np.hsplit(a,3))
 

<type 'list'>
 

>>> 
 


 

split，取axis=1
 

  1. >>> a
  2. array([[0, 1, 2],
  3.        [3, 4, 5],
  4.        [6, 7, 8]])
  5. >>> np.split(a,3,axis=1)
  6. [array([[0],
  7.        [3],
  8.        [6]]), array([[1],
  9.        [4],
  10.        [7]]), array([[2],
  11.        [5],
  12.        [8]])]
 

（2）垂直分割
 

vsplit
 

  1. >>> a
  2. array([[0, 1, 2],
  3.        [3, 4, 5],
  4.        [6, 7, 8]])
  5. >>> np.vsplit(a,3)
  6. [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
 

split，取axis=0
 

 

  1. >>> np.split(a,3,axis=0)
  2. [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
 

（3）深度分割
 

所谓深度分割，就是按照深度方向分割数组
 

首先创建一个3维数组
 

  1. >>> c=np.arange(27).reshape(3,3,3)
  2. >>> c.shape
  3. (3L, 3L, 3L)
  4. >>> c
  5. array([[[ 0,  1,  2],
  6.         [ 3,  4,  5],
  7.         [ 6,  7,  8]],
  8.        [[ 9, 10, 11],
  9.         [12, 13, 14],
  10.         [15, 16, 17]],
  11.        [[18, 19, 20],
  12.         [21, 22, 23],
  13.         [24, 25, 26]]])
 

然后利用dsplit函数进行深度分割
 

  1. >>> np.dsplit(c,3)
  2. [array([[[ 0],
  3.         [ 3],
  4.         [ 6]],
  5.        [[ 9],
  6.         [12],
  7.         [15]],
  8.        [[18],
  9.         [21],
  10.         [24]]]), array([[[ 1],
  11.         [ 4],
  12.         [ 7]],
  13.        [[10],
  14.         [13],
  15.         [16]],
  16.        [[19],
  17.         [22],
  18.         [25]]]), array([[[ 2],
  19.         [ 5],
  20.         [ 8]],
  21.        [[11],
  22.         [14],
  23.         [17]],
  24.        [[20],
  25.         [23],
  26.         [26]]])]
 

分割成了1个列表，长度为3
 

 

  1. >>> type(np.dsplit(c,3))
  2. <type 'list'>
  3. >>> len(np.dsplit(c,3))
  4. 3
 

8数组的属性
 

ndim：给出数组的维数或者数组轴的个数
 

size：给出数组元素的总个数
 

itemsize：给出数组中的元素在内存中所占用的字节数
 

nbytes：size*itemsize
 

T：与transpose一样
 

复数的虚部用j表示：
 

 

  1. >>> b=np.array([1.j+1,2.j+3])
  2. >>> b
  3. array([ 1.+1.j,  3.+2.j])
 

real：给出复数数组的实部：
 

 

  1. >>> b.real
  2. array([ 1.,  3.])
 

imag：给出复数数组的虚部： 
 

  1. >>> b.imag
  2. array([ 1.,  2.])
 

fliter属性将返回一个numpy.flatiter对象：
 

 

  1. >>> z=np.arange(6).reshape(3,2)
  2. >>> z
  3. array([[0, 1],
  4.        [2, 3],
  5.        [4, 5]])
  6. >>> f=z.flat
  7. >>> f
  8. <numpy.flatiter object at 0x00000000032BED00>
  9. >>> for item in f:
  10.     print item
  11. 0
  12. 1
  13. 2
  14. 3
  15. 4
  16. 5
 

还可以直接用flatiter队对象获取一个数组元素：
 

 

  1. >>> z.flat[2]
  2. 2
 

或者获取多个元素：
 

  1. >>> z.flat[[0,1,2]]
  2. array([0, 1, 2])
 

falt是一个可赋值的属性，赋值将导致整个数组数组的元素都被覆盖：
 

  1. >>> z.flat=1
  2. >>> z
  3. array([[1, 1],
  4.        [1, 1],
  5.        [1, 1]])
 

或者：
 

  1. >>> z.flat[[0,1,2,3]]=10
  2. >>> z
  3. array([[10, 10],
  4.        [10, 10],
  5.        [ 1,  1]])
 

9数组的转换
 

tolist函数：将Numpy转换为Python列表
 

  1. >>> z
  2. array([[10, 10],
  3.        [10, 10],
  4.        [ 1,  1]])
  5. >>> z.tolist()
  6. [[10, 10], [10, 10], [1, 1]]
  7. >>> type( z.tolist())
  8. <type 'list'>
 

 

 

 

  1. >>> b
  2. array([ 1.+1.j,  3.+2.j])
  3. >>> b.tolist()
  4. [(1+1j), (3+2j)]
  5. >>> type(b.tolist())
  6. <type 'list'>
 


 

astype函数可以在转换数组时指定数据类型：
 

 

  1. >>> b
  2. array([ 1.+1.j,  3.+2.j])
  3. >>> b.astype(int)
  4. Warning (from warnings module):
  5.   File "__main__", line 2
  6. ComplexWarning: Casting complex values to real discards the imaginary part
  7. array([1, 3])
  9. >>> b.astype('complex')
  10. array([ 1.+1.j,  3.+2.j])
  11. >>> b.astype(complex)
  12. array([ 1.+1.j,  3.+2.j])

                

        

        

    

  


    

      

        

            

              
                
                  付修磊
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Numpy数据分析相关API总结--学习笔记

				
			

			

				

					a18612039484的博客
				

				

					09-06
					
					1241
					
				

			

		

		

			
				
目录Numpy数据分析API总结numpy常见函数加载文件案例，绘制K线图算数平局值加权平均值最大值、最小值、极差中位数标准差移动平均卷积实现移动平均布林带线型预测线型拟合协方差相关系数相关矩阵多项式拟合数据平滑符号数组数组处理函数矢量化矩阵使用矩阵实现斐波那契数列通用函数加法通用函数除法通用函数三角函数特征值与特征向量奇异值分解快速傅里叶变换FFT基于傅里叶变换的频域滤波概率分布联合间接排序插入...

			
		

	



                

            
              



	

		

			

				
					
pytorch学习（一）

				
			

			

				

					迪斯尼在逃女巫的博客
				

				

					03-13
					
					512
					
				

			

		

		

			
				
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

索引前言一、pandas是什么？二、使用步骤1.数据类型的转换2.读入数据总结

前言
这篇文章是B站上莫烦python的pytorch教程，听课随笔记录一下

提示：以下是本篇文章正文内容，下面案例可供参考
一、pandas是什么？
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
二、使用步骤
1.数据类型的转换
代码如下（示例）：还有很多torch的指令，具体可以上官网查看
import  to

			
		

	



              


  
              

                


	

		

			

				
					
新手小白自学Python调用时出现一串字符，大佬救命！

				
			

			

				

					m0_50937563的博客
				

				

					12-23
					
					1749
					
				

			

		

		

			
				
新手小白写Python调用函数出现一串字符
用的编译器是sublime text3
以上是我书写的代码想调用用户的姓名并挨个打招呼，我想象中的运行结果是：
hello，one ！
hello，two ！
hello，three ！
然而……

hello,<built-in method title of str object at 0x000001972BA84770>
hello,<built-in method title of str object at 0x000001972BA

			
		

	





	

		

			

				
					
【NumPy】基础知识

					
最新发布

				
			

			

				

					m0_74183164的博客
				

				

					09-07
					
					484
					
				

			

		

		

			
				
NumPy是Python的第三方库，要使用需要先导入。在pycharm中可以通过np.来查看numpy的可用函数。np.函数名?查看对应函数的详细信息。

			
		

	



		

			
		



	

		

			

				
					
Pytorch_basics_main

				
			

			

				

					AIHUBEI的博客
				

				

					11-21
					
					552
					
				

			

		

		

			
				
Pytorch 打卡第一天，Pytorch基础

			
		

	





	

		

			

				
					
Tensorflow学习笔记-第二节程序结构

				
			

			

				

					TI__boyue的博客
				

				

					03-11
					
					245
					
				

			

		

		

			
				
TensorFlow程序分为两个独立的部分：
1. 构建任何拟创建神经网络的蓝图
2. 计算图的定义及其执行
计算图：
计算图是包含节点和边的网络。本节定义所有要使用的数据，也就是张量（tensor）对象（常量、变量和占位符），同时定义要执行的所有计算，即运算操作对象（Operation Object，简称 OP）。
每个节点可以有零个或多个输入，但只有一个输出。网络中的节点表示对象（张量和运算操...

			
		

	





	

		

			

				
					
NumPy-Matplotlib-TensorFlow简介：张量计算的NumPy基础知识； Matplotlib用于数据可视化

				
			

			

				

					02-05
				

			

		

		

			
				
**NumPy基础知识**  NumPy是Python编程语言中的一个核心库，专为处理多维数据而设计。它提供了高效的数组对象，即`ndarray`（n-dimensional array），支持大量的维度操作、工具以及数学函数。NumPy的`ndarray`与...

			
		

	





	

		

			

				
					
numpy基础知识（持续更新）

				
			

			

				

					12-22
				

			

		

		

			
				
以下是一些关于NumPy的基础知识：  1. **导入NumPy**: 首先，我们需要导入NumPy库，通常使用`import numpy as np`的语法。  2. **创建数组**: NumPy提供了多种创建数组的方法。如`np.array()`可以创建一维和二维数组...

			
		

	





	

		

			

				
					
python numpy 基础知识

				
			

			

				

					05-08
				

			

		

		

			
				
在cs231N 公开课上面打印下载的课件，感觉讲的蛮好，蛮有用的。

			
		

	





	

		

			

				
					
Python零基础速成班-第15讲-Python for Numpy 基础知识及应用.ipynb

				
			

			

				

					06-18
				

			

		

		

			
				
采用Jupyter Notebook原装教程，.ipynb格式拷贝到Jupyter Notebook目录下即可运行，网页交互式可视化Python编程，全中文注解，下载即用，对初学者非常友好，也可作为Python程序员基础知识的补充再学习材料。...

			
		

	





	

		

			

				
					
Numpy 轻松学

				
			

			

				

					sowhat
				

				

					07-12
					
					8799
					
				

			

		

		

			
				
1.  Numpy 简介
NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。底层是C语言编写出来然后嵌入到python中的。
2. 矩阵
在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，一般情况下是(n,m) 表示 

			
		

	





	

		

			

				
					
Python <built-in method items of dict object at 0x0000000002B6C8C8> 问题解决

					
热门推荐

				
			

			

				

					yeziyqf的博客
				

				

					07-27
					
					2万+
					
				

			

		

		

			
				
在把字典类型转换为list类型时遇到问题：<built-in method items of dict object at 0x0000000002B6C8C8> 相应代码为：print a.values()
后发现是因为这样做只是返回一个“循环体 iter”, 你需要把它们显示出来需要用 list（dic.keys)

			
		

	





	

		

			

				
					
菜鸟之路——机器学习之非线性回归个人理解及python实现

				
			

			

				

					weixin_30794491的博客
				

				

					08-31
					
					97
					
				

			

		

		

			
				
关键词：
梯度下降：就是让数据顺着梯度最大的方向，也就是函数导数最大的放下下降，使其快速的接近结果。
Cost函数等公式太长，不在这打了。网上多得是。
这个非线性回归说白了就是缩小版的神经网络。
python实现：

 1 import numpy as np
 2 import random
 3 
 4 def graientDescent(x,y,theta,alpha,m...

			
		

	





	

		

			

				
					
Variable类型和自动微分模块

				
			

			

				

					from top to bottom
				

				

					11-26
					
					848
					
				

			

		

		

			
				
Variable是PyTorch中的另一个变量类型。一旦张量被转换成Variable类型便可以实现自动求导。

Variable对象和Tensor对象之间的转换


>>> import torch
>>> from torch.autograd import Variable

>>> a = torch.FloatTensor([4])
>>> print(Variable(a))  # 将张量转换成Variable...

			
		

	





	

		

			

				
					
pytorh入门

				
			

			

				

					qq_42906486的博客
				

				

					09-12
					
					714
					
				

			

		

		

			
				
一些关于pytorch入门的知识，欢迎大家一起交流学习

			
		

	





	

		

			

				
					
Python【学习笔记】 调用函数加括号和不加括号的区别

				
			

			

				

					Mod_13的博客
				

				

					08-22
					
					1977
					
				

			

		

		

			
				
调用函数时加括号与不加括号的区别：

一、不带括号时，调用的是这个函数本身 ，是整个函数体，是一个函数对象，不须等该函数执行完成

二、带括号（参数或者无参），调用的是函数的执行结果，须等该函数执行完成的结果


# -*- coding:utf-8 -*-
 
defbracket(data):
 
return data
 
if __name__ == '__main__':
 ...

			
		

	





	

		

			

				
					
Numpy_第一天

				
			

			

				

					沧海一shu_
				

				

					10-26
					
					810
					
				

			

		

		

			
				
目录

一  创建数组

1.1多维数组的创建

二 多维数组的切片

三 数组的属性

四 数组的运算

3.1点积的运算规则

3.2其他特殊运算

五 索引

六 布尔屏蔽

七 Where函数


1.一个强大的多维数组对象

2.复杂的广播功能

3.集成Fortran和C/C++

4.有用的线性代数，傅里叶转换和随机数能力


一  创建数组

numpy围绕这些成为数组的实物来展开...

			
		

	





	

		

			

				
					
22月18，numpy-数组的形状

				
			

			

				

					qq_36530187的博客
				

				

					04-18
					
					340
					
				

			

		

		

			
				
import numpy as np
>>> 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]]])
>>> t1 = np.arange(24).re.

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值