python/numpy基础知识，order=C F A K，各个数据索引顺序的区别？

已于 2022-04-30 21:10:49 修改
阅读量2.9k 收藏 12
点赞数 4
分类专栏： Python 文章标签： c语言 python numpy fortran
于 2022-03-01 15:48:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PSpiritV/article/details/123207549
版权

一、哪些函数会用到order参数？

numpy.copy

numpy.reshape

numpy.ravel

numpy.flatten

二、C F A K之间的区别是什么？

C是最后一个索引变化最快。

F是第一个索引变化最快。

A是C或F中的一种，也就说也与索引相关。

K是唯一不与索引相关，只与数据缓存顺序相关的ordering，具体来说对于数组[3,1,2]，因为内部对按大小顺序进行缓存，所以先取小的数再取大的数。

# 1、生成形状为（2，2，3）的ndarray数据
a = np.arange(12).reshape(2,3,2).swapaxes(1,2)
print(a)
# 输出为▼▼▼▼
# [[[ 0  2  4]
#  [ 1  3  5]]
# [[ 6  8 10]
#  [ 7  9 11]]]

# 2、order='C'，按照a[0,0,0]-->a[0,0,1]-->a[0,0,2]-->a[0,1,0]...的顺序索引
print(a.ravel(order='C'))
# 输出为[ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11]

# 3、order='F'，按照a[0,0,0]-->a[1,0,0]-->a[0,1,0]-->a[1,1,0]...的顺序索引
print(a.ravel(order='F'))
# 输出为[ 0,  6,  1,  7,  2,  8,  3,  9,  4, 10,  5, 11]

# 4、order='A'，按照C或F中的一种顺序进行，python中以C顺序进行
print(a.ravel(order='A'))
# 输出为[ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11]

# 5、order='K'，按照数据在内存中的缓存顺序进行，一般来说按数值大小顺序进行缓存
print(a.ravel(order='K'))
# 输出为[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]

 

三、对order='K'的探究

刚刚有一个可爱的小伙伴在评论区质疑我对K的描述，然后我想ta质疑的是啊！我复现了他的代码，发现确实不一定按1,2,3,4,5的顺序去铺排。

x = np.array([[[ 1 , 0],
[ 3 , 2],
[ 5 , 4]],

[[ 7 , 6],
[ 9 , 8],
[11, 10]],

[[12 ,13],
[14 ,15],
[16 ,17]]]).reshape(3,3,2).swapaxes(1,2)
z=np.ravel(x, order='K')

output:[ 1 0 3 2 5 4 7 6 9 8 11 10 12 13 14 15 16 17]

 下面开始我的实验吧！朋友有难我帮忙。

3.1 如果数据是4维的，那么是按照[0,0,0,0]-->[0,0,0,1]-->[0,1,0,0]-->[0,1,0,1]-->[0,0,1,0]-->[0,0,1,1]-->[0,1,1,0]-->[0,1,1,1]...的顺序索引，也即先遍历倒数第1维、再遍历倒数第3维、再遍历倒数第2维、最后遍历倒数第4维。

print(np.arange(24).reshape(2,3,2,2).swapaxes(1,2))
print(np.arange(24).reshape(2,3,2,2).swapaxes(1,2).ravel(order='k'))

# [[[[[ 0  1]
#     [ 2  3]]

#    [[ 8  9]
#     [10 11]]

#    [[16 17]
#     [18 19]]]


#   [[[ 4  5]
#     [ 6  7]]

#    [[12 13]
#     [14 15]]

#    [[20 21]
#     [22 23]]]]



#  [[[[24 25]
#     [26 27]]

#    [[32 33]
#     [34 35]]

#    [[40 41]
#     [42 43]]]


#   [[[28 29]
#     [30 31]]

#    [[36 37]
#     [38 39]]

#    [[44 45]
#     [46 47]]]]]
# [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
#  24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47]

3.2 如果数据是5维的，那么是按照[0,0,0,0,0]-->[0,0,0,0,1]-->[0,0,0,0,0]-->[0,1,0,1]-->[0,0,1,0]-->[0,0,1,1]-->[0,1,1,0]-->[0,1,1,1]...的顺序索引，也即先遍历倒数第1维、再遍历倒数第2维、再遍历倒数第4维、再遍历倒数第3维、最后遍历倒数第5维。

对照3.1得出来的结论，瞬间不好了！程序本身绝对是有一套稳定的算法，至少在这两个实验中我觉得简直就是薛定谔的猫——真是乱七八糟！

print(np.arange(48).reshape(2,3,2,2,2).swapaxes(1,2))
print(np.arange(48).reshape(2,3,2,2,2).swapaxes(1,2).ravel(order='k'))

# [[[[[ 0  1]
#     [ 2  3]]

#    [[ 8  9]
#     [10 11]]

#    [[16 17]
#     [18 19]]]


#   [[[ 4  5]
#     [ 6  7]]

#    [[12 13]
#     [14 15]]

#    [[20 21]
#     [22 23]]]]



#  [[[[24 25]
#     [26 27]]

#    [[32 33]
#     [34 35]]

#    [[40 41]
#     [42 43]]]


#   [[[28 29]
#     [30 31]]

#    [[36 37]
#     [38 39]]

#    [[44 45]
#     [46 47]]]]]
# [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
#  24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47]

转换一下思路，官网已经说了，K就是按内存顺序来索引的；那么这个内存顺序是在创建array的时候发生，还是根据已经缓存在python的buffer中的常用数字的顺序来确定呢？

下面看实验3.3，得出来的结论是：内存顺序是在创建array的时候发生，因为两个数组的元素0的地址不一样；说明在分别创建这两个数组的时候，其中的元素是开拓了新的内存区，而非直接引用buffer中的常用数字的地址。

a = np.arange(24).reshape(2,3,2,2).swapaxes(1,2)
b = np.arange(48).reshape(2,3,2,2,2).swapaxes(1,2)
 
a[0,0,0,0] is b[0,0,0,0,0]  # False

接着看实验3.4，得出来的结论是：一个数组如果是通过arange得出来的，那么内存顺序和数字大小相关，从前到后数值逐渐递增；而如果一个数组是逐元素均用表达式给出，那么内存顺序和order='c'的一样；因为存入内存的顺序是'c'（计算机不可能说一下子吃一个大块头吧？肯定是逐元素存入内存的，顺序就默认是'c'），所以用a.ravel(order='k')平铺出来的顺序也跟内存顺序一样是'c'。

实验3.4的子实验（1）如下：

a = np.arange(96).reshape(2,3,2,2,2,2).swapaxes(1,2)
print(a)

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

#           [[ 4,  5],
#            [ 6,  7]]],


#          [[[16, 17],
#            [18, 19]],

#           [[20, 21],
#            [22, 23]]],


#          [[[32, 33],
#            [34, 35]],

#           [[36, 37],
#            [38, 39]]]],



#         [[[[ 8,  9],
#            [10, 11]],

#           [[12, 13],
#            [14, 15]]],


#          [[[24, 25],
#            [26, 27]],

#           [[28, 29],
#            [30, 31]]],


#          [[[40, 41],
#            [42, 43]],

#           [[44, 45],
#            [46, 47]]]]],




#        [[[[[48, 49],
#            [50, 51]],

#           [[52, 53],
#            [54, 55]]],


#          [[[64, 65],
#            [66, 67]],

#           [[68, 69],
#            [70, 71]]],


#          [[[80, 81],
#            [82, 83]],

#           [[84, 85],
#            [86, 87]]]],



#         [[[[56, 57],
#            [58, 59]],

#           [[60, 61],
#            [62, 63]]],


#          [[[72, 73],
#            [74, 75]],

#           [[76, 77],
#            [78, 79]]],


#          [[[88, 89],
#            [90, 91]],

#           [[92, 93],
#            [94, 95]]]]]])

再平铺开： 

a.ravel(order='k')

# 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, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
#        34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
#        51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
#        68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
#        85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95])

 

然后再利用子实验（1）得到的array进行子实验（2）：最终平铺出来的结果顺序从前到后并不完全是按数值大小递增，换句话说这个顺序和order='c'的一样。

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

          [[ 4,  5],
           [ 6,  7]]],


         [[[16, 17],
           [18, 19]],

          [[20, 21],
           [22, 23]]],


         [[[32, 33],
           [34, 35]],

          [[36, 37],
           [38, 39]]]],



        [[[[ 8,  9],
           [10, 11]],

          [[12, 13],
           [14, 15]]],


         [[[24, 25],
           [26, 27]],

          [[28, 29],
           [30, 31]]],


         [[[40, 41],
           [42, 43]],

          [[44, 45],
           [46, 47]]]]],




       [[[[[48, 49],
           [50, 51]],

          [[52, 53],
           [54, 55]]],


         [[[64, 65],
           [66, 67]],

          [[68, 69],
           [70, 71]]],


         [[[80, 81],
           [82, 83]],

          [[84, 85],
           [86, 87]]]],



        [[[[56, 57],
           [58, 59]],

          [[60, 61],
           [62, 63]]],


         [[[72, 73],
           [74, 75]],

          [[76, 77],
           [78, 79]]],


         [[[88, 89],
           [90, 91]],

          [[92, 93],
           [94, 95]]]]]])

print(a.ravel(order='k'))

# array([ 0,  1,  2,  3,  4,  5,  6,  7, 16, 17, 18, 19, 20, 21, 22, 23, 32,
#        33, 34, 35, 36, 37, 38, 39,  8,  9, 10, 11, 12, 13, 14, 15, 24, 25,
#        26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
#        51, 52, 53, 54, 55, 64, 65, 66, 67, 68, 69, 70, 71, 80, 81, 82, 83,
#        84, 85, 86, 87, 56, 57, 58, 59, 60, 61, 62, 63, 72, 73, 74, 75, 76,
#        77, 78, 79, 88, 89, 90, 91, 92, 93, 94, 95])
键盘即钢琴
关注
专栏目录
Python的Numpy库中参数order的可选值C、F、A、K的意义
昊虹AI笔记
07-18 1219
Python的Numpy库中参数order的可选值C、F、A、K的意义
python order函数_Python学习日记(十一) 内置函数
weixin_28717647的博客
02-09 1506
什么是内置函数?就是Python中已经写好了的函数,可以直接使用内置函数图表:以3.6.2为例内置函数分类:一、反射相关二、基础数据类型相关1.和数字相关(1)数据类型a.bool()把一个值转换成布尔值li = ['',[],1,12,0]for i inli:print(bool(i))#False#False#True#True#Falseb.int()把一个值转换成整型num = inpu...
Python MySQL Order By - qikegu.com
06-20 381
Python MySQL 教程 Python MySQL 入门 Python MySQL 创建数据库 Python MySQL 创建表 Python MySQL 插入表 Python MySQL Select Python MySQL Where Python MySQL Order By Python MySQL Delete Python MySQL 删除表 Python ...
numpy.ravel(a, order='C')
danerer的专栏
09-30 3164
numpy.ravel(a, order=‘C’) a是要进行改变形状的数组 order : {‘C’,’F’, ‘A’, ‘K’}, optional 由ravel()产生的数组中元素的顺序通常是“C风格”，也就是说，最右边的索引“改变最快”，所以[0,0]之后的元素是[0,1] 。如果数组被重新塑造成其他形状，数组又被视为“C-style”。NumPy通常创建按此顺序存储的数组，因此r...
Python学习笔记之函数基础
XXXGDZM的博客
09-24 340
** Python学习笔记 ** 目录 一、函数 1.引入 2.函数的定义 3.函数的格式 4.定义带有参数的函数 5.定义带返回值的函数 二、函数的参数 1.位置参数 2.关键字参数 3.默认参数 4.可变参数 （1）元组参数 （2）字典参数 三、函数文档注释 四、函数的嵌套及其调用 1.函数的嵌套 2.函数之间的调用 五、递归函数 一、函数 1.引用 如果要计算三个不同半径的圆的面积我们可以这么写： r1=1 r2=2 r3=3 # 1.求r1的面积 s1=3.14 * r1 * r **
numpy.array | order=‘C‘ | 简记
专注于AI领域前沿技术学习与分享：目标检测、图像修复、超分重建、AI工程化
07-12 622
遇到代码如下： image_resized = np.array(image_resized, dtype=np.float32, order='C') numpy.array API https://numpy.org/doc/stable/reference/generated/numpy.array.html#
Python基础 Numpy菜鸟教程
weixin_46262668的博客
10-09 3060
Numpy Python
Python/numpy之ravel()多维数据展平函数
Snfiltration
12-16 7197
Python/numpy之ravel()多维数据展平函数 可参考官方文档numpy.ravel或末尾摘抄内容 ravel()将多维数据展平为一维数据，可以选择不同的数据索引方式（见文档参数四个可选值） 使用： >>> import numpy as np >>> a = np.array([[1,2,3],[4,5,6]]) >>> a array([[1, 2, 3], [4, 5, 6]]) >>> a.ravel
Python数据分析与应用---Numpy数组计算基础（课后作业题）
最新发布
m0_72226951的博客
03-20 1183
NumPy数组计算基础
Python的NumPy库（一）基础用法
10-05 285
NumPy是Python中科学计算的基础包，它代表 “Numeric Python”。Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。也开发了另一个包 Numarray ，它拥有一些额外的功能。2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。NumPy的核心是多维数组（ndarray）
Python之Numpy的超实用基础详细教程
09-18
【Python之Numpy的超实用基础详细教程】 Numpy是Python中用于科学计算的核心库，它的功能强大，尤其在处理大型多维数组和矩阵时表现出色。Numpy提供了高效的数值计算功能，支持广泛的数学操作，如线性代数、傅立叶...
【一文读懂】python 中的 numpy.reshape(a, newshape, order=‘C‘) 详细说明及实例讲解
夏侯依风 的博客
05-10 8533
文章目录numpy.reshape(a, newshape, order='C')1. 参数2. 返回值3. 如何理解 "新形状newshape，与原形状兼容，元素个数相同" ?4. 如何理解 order = {'C', 'F', 'A'} ? numpy.reshape(a, newshape, order=‘C’) 在不改变数据的情况下给数组一个新的形状。 就是先将数组按给定索引顺序一维展开，然后按与展开时相同的索引顺序将展开的元素填充到新数组中； 即等价于 np.reshape(np.revel(a
python order函数_Python进阶内容（一）--- 高阶函数 High order function
weixin_35411439的博客
02-09 565
0. 问题# 本文将围绕这段代码进行Python中高阶函数相关内容的讲解# 文中所有代码的兼容性要求为：Python 3.6，IPython 6.1.0def addspam(fn):def new(*args):print("spam,spam,spam")return fn(*args)return new@addspamdef useful(a,b):print(a**2+b**2)if _...
python中的列表排序操作
清流弯弯
10-14 5885
   Python lists have a built-in sort() method that modifies the list in-place and a sorted() built-in function that builds a new sorted list from an iterable. There are many ways to use them t
python实现选择排序
qq_36209859的博客
03-09 91
python实现选择排序 2010-3-9 1 代码 def findsmall(list): small=list[0] lenth=len(list) small_index=0 for i in range(1,lenth): if list[i]<small: small=list[i] ...
python dict order by key 字典关键字排序
w2008145338的专栏
05-14 3207
from operator import itemgetter  通过使用operator模块的itemgetter函数，可以非常容易的排序这样的数据结构 rows = [ {'fname': 'Brian', 'lname': 'Jones', 'uid': 1003}, {'fname': 'David', 'lname': 'Beazley', 'uid': 10
numpy中间的order
pfm685757的专栏
01-11 1024
reshape 它的含义说的最清楚的一段话： You can think of reshaping as first raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same ki...
numpy高级应用—数组操作
Jakob_Hu的博客
03-31 874
数组操作与广播ndarray对象内部机制概要numpy数据类型体系 ndarray对象内部机制概要 numpy的ndarray功能很强大因为其内部组成足够复杂，包括 （1）一个指向数组的内存指针 （2）数据类型dtype （3）一个表示数据形状的元祖，使用shape属性可以调用 （4）一个跨度元祖，这个是内部机制的关键，使用strides属性可以获取。 3×4×5的一个多维数组，其跨度为（...
深入理解numpy库中的order参数
Reborn214的博客
05-01 4089
先引入一个代码实例： import numpy as np x1 = np.array( [[[ 1 , 0], [ 3 , 2], [ 5 , 4]], [[ 7 , 6], [ 9 , 8], [11, 10]], [[12 ,13], [14 ,15], [16 ,17]]]).reshape(3,2,3,order='C') x = np.array( [[[ 1 , 0], [ 3 , 2], [
深入理解numpy数组索引与切片
`order`参数默认为'C'，代表按照C语言的顺序存储数据，也可以设置为'F'，表示按照Fortran语言的顺序存储。 除了基本的索引和切片，NumPy还支持更高级的索引技术，如布尔索引、整数列表索引和切片组合。例如，你可以...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值