-
Notifications
You must be signed in to change notification settings - Fork 54
/
Copy pathArrayTraversal.html
323 lines (296 loc) · 26.5 KB
/
ArrayTraversal.html
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
<!DOCTYPE html>
<html class="writer-html5" lang="en" >
<head>
<meta charset="utf-8" /><meta content="Topic: Numpy array traversal ordering, Difficulty: Medium, Category: Section" name="description" />
<meta content="row-major order, c order, column-major order, f order, traversal, array iteration" name="keywords" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Iterating Over Arrays & Array-Traversal Order — Python Like You Mean It</title>
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../_static/css/theme.css" type="text/css" />
<link rel="stylesheet" href="../_static/my_theme.css" type="text/css" />
<!--[if lt IE 9]>
<script src="../_static/js/html5shiv.min.js"></script>
<![endif]-->
<script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script src="../_static/jquery.js"></script>
<script src="../_static/underscore.js"></script>
<script src="../_static/doctools.js"></script>
<script async="async" src="https://www.googletagmanager.com/gtag/js?id=UA-115029372-1"></script>
<script src="../_static/gtag.js"></script>
<script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
<script>window.MathJax = {"tex": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true}, "options": {"ignoreHtmlClass": "tex2jax_ignore|mathjax_ignore|document", "processHtmlClass": "tex2jax_process|mathjax_process|math|output_area"}}</script>
<script defer="defer" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
<script src="../_static/js/theme.js"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
<link rel="next" title="“Vectorized” Operations: Optimized Computations on NumPy Arrays" href="VectorizedOperations.html" />
<link rel="prev" title="Functions for Creating NumPy Arrays" href="FunctionsForCreatingNumpyArrays.html" />
</head>
<body class="wy-body-for-nav">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-scroll">
<div class="wy-side-nav-search" >
<a href="../index.html" class="icon icon-home"> Python Like You Mean It
</a>
<div class="version">
1.4
</div>
<div role="search">
<form id="rtd-search-form" class="wy-form" action="../search.html" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
<p class="caption" role="heading"><span class="caption-text">Table of Contents:</span></p>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../intro.html">Python Like You Mean It</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_1.html">Module 1: Getting Started with Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_2.html">Module 2: The Essentials of Python</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_2_problems.html">Module 2: Problems</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="../module_3.html">Module 3: The Essentials of NumPy</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="IntroducingTheNDarray.html">Introducing the ND-array</a></li>
<li class="toctree-l2"><a class="reference internal" href="AccessingDataAlongMultipleDimensions.html">Accessing Data Along Multiple Dimensions in an Array</a></li>
<li class="toctree-l2"><a class="reference internal" href="BasicArrayAttributes.html">Basic Array Attributes</a></li>
<li class="toctree-l2"><a class="reference internal" href="FunctionsForCreatingNumpyArrays.html">Functions for Creating NumPy Arrays</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Iterating Over Arrays & Array-Traversal Order</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#How-to-Traverse-an-Array:-Row-major-(C)-vs-Column-major-(F)-Traversal-Ordering">How to Traverse an Array: Row-major (C) vs Column-major (F) Traversal Ordering</a></li>
<li class="toctree-l3"><a class="reference internal" href="#Links-to-Official-Documentation">Links to Official Documentation</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="VectorizedOperations.html">“Vectorized” Operations: Optimized Computations on NumPy Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="Broadcasting.html">Array Broadcasting</a></li>
<li class="toctree-l2"><a class="reference internal" href="BasicIndexing.html">Introducing Basic and Advanced Indexing</a></li>
<li class="toctree-l2"><a class="reference internal" href="AdvancedIndexing.html">Advanced Indexing</a></li>
<li class="toctree-l2"><a class="reference internal" href="AutoDiff.html">Automatic Differentiation</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../module_3_problems.html">Module 3: Problems</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_4.html">Module 4: Object Oriented Programming</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_5.html">Module 5: Odds and Ends</a></li>
<li class="toctree-l1"><a class="reference internal" href="../changes.html">Changelog</a></li>
</ul>
</div>
</div>
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="../index.html">Python Like You Mean It</a>
</nav>
<div class="wy-nav-content">
<div class="rst-content">
<div role="navigation" aria-label="Page navigation">
<ul class="wy-breadcrumbs">
<li><a href="../index.html" class="icon icon-home"></a> »</li>
<li><a href="../module_3.html">Module 3: The Essentials of NumPy</a> »</li>
<li>Iterating Over Arrays & Array-Traversal Order</li>
<li class="wy-breadcrumbs-aside">
<a href="../_sources/Module3_IntroducingNumpy/ArrayTraversal.md.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
<div itemprop="articleBody">
<style>
/* CSS overrides for sphinx_rtd_theme */
/* 24px margin */
.nbinput.nblast.container,
.nboutput.nblast.container {
margin-bottom: 19px; /* padding has already 5px */
}
/* ... except between code cells! */
.nblast.container + .nbinput.container {
margin-top: -19px;
}
.admonition > p:before {
margin-right: 4px; /* make room for the exclamation icon */
}
/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
.math {
text-align: unset;
}
</style>
<div class="section" id="Iterating-Over-Arrays-&-Array-Traversal-Order">
<h1>Iterating Over Arrays & Array-Traversal Order<a class="headerlink" href="#Iterating-Over-Arrays-&-Array-Traversal-Order" title="Permalink to this headline"></a></h1>
<p>In this section, you will learn:</p>
<ul class="simple">
<li><p>About NumPy’s functions for iterating over an array</p></li>
<li><p>That there is more than one valid way for NumPy to perform this operation, which amounts to how NumPy traverses a multidimensional array.</p></li>
<li><p>The row-major array traversal methodology, which is utilized by NumPy by default.</p></li>
</ul>
<p>NumPy provides valuable tools for iterating over any array, such that each element can be visited in the array, regardless of the array’s shape. For example, recall that Python’s built-in <code class="docutils literal notranslate"><span class="pre">enumerate</span></code> function permits us to produce each item in an iterable, along with its index of iteration:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># enumerating the items in an iterable</span>
<span class="o">>>></span> <span class="p">[</span><span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="s2">"abcdef"</span><span class="p">)]</span>
<span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">'a'</span><span class="p">),</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="s1">'c'</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="s1">'d'</span><span class="p">),</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="s1">'e'</span><span class="p">),</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="s1">'f'</span><span class="p">)]</span>
</pre></div>
</div>
<p>Similarly, NumPy provides the <a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndenumerate.html#numpy.ndenumerate">ndenumerate</a> function, which enumerates each element in an N-dimensional array, specifying the N-dimensional index for each element.</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="go"># Demonstrating `np.ndenumerate`.</span>
<span class="go"># A shape-(2, 2, 3) array</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[[</span> <span class="mi">25</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="o">-</span><span class="mi">35</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span> <span class="mi">9</span><span class="p">,</span> <span class="o">-</span><span class="mi">40</span><span class="p">,</span> <span class="o">-</span><span class="mi">29</span><span class="p">]],</span>
<span class="gp">...</span>
<span class="gp">... </span> <span class="p">[[</span> <span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">37</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span> <span class="mi">17</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">45</span><span class="p">]]])</span>
<span class="gp">>>> </span><span class="p">[</span><span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">np</span><span class="o">.</span><span class="n">ndenumerate</span><span class="p">(</span><span class="n">x</span><span class="p">)]</span>
<span class="go">[((0, 0, 0), 25),</span>
<span class="go"> ((0, 0, 1), 6),</span>
<span class="go"> ((0, 0, 2), -35),</span>
<span class="go"> ((0, 1, 0), 9),</span>
<span class="go"> ((0, 1, 1), -40),</span>
<span class="go"> ((0, 1, 2), -29),</span>
<span class="go"> ((1, 0, 0), -8),</span>
<span class="go"> ((1, 0, 1), 2),</span>
<span class="go"> ((1, 0, 2), -37),</span>
<span class="go"> ((1, 1, 0), 17),</span>
<span class="go"> ((1, 1, 1), 10),</span>
<span class="go"> ((1, 1, 2), -45)]</span>
</pre></div>
</div>
<p>See that each triplet of integers specifies the index for the corresponding array element:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="go">25</span>
<span class="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="go">6</span>
<span class="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span>
<span class="go">-35</span>
<span class="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="go">9</span>
</pre></div>
</div>
<p>See <a class="reference external" href="https://numpy.org/doc/stable/reference/routines.indexing.html#iterating-over-arrays">the official NumPy documentation</a> for a complete listing of functions that facilitate iterating over arrays. The official documentation also provides <a class="reference external" href="https://numpy.org/doc/stable/reference/arrays.nditer.html#iterating-over-arrays">a detailed treatment of array iteration</a>, which is far more detailed than is warranted here. Next, we must discuss the default ordering that NumPy uses when traversing a
N-dimensional array.</p>
<div class="section" id="How-to-Traverse-an-Array:-Row-major-(C)-vs-Column-major-(F)-Traversal-Ordering">
<h2>How to Traverse an Array: Row-major (C) vs Column-major (F) Traversal Ordering<a class="headerlink" href="#How-to-Traverse-an-Array:-Row-major-(C)-vs-Column-major-(F)-Traversal-Ordering" title="Permalink to this headline"></a></h2>
<p>Note the order in which <code class="docutils literal notranslate"><span class="pre">np.ndenumerate</span></code> iterated over <code class="docutils literal notranslate"><span class="pre">x</span></code>. It first traversed the columns within row-0 of sheet-0 of <code class="docutils literal notranslate"><span class="pre">x</span></code>, and then it traversed the columns within the row-1 of sheet-0, and so on. What is special about this traversal order? Why, for instance, didn’t it traverse the rows within a given column instead? We can also see that there is not a unique ordering for a <code class="docutils literal notranslate"><span class="pre">reshape</span></code> function to adhere to. For example, the following reshape operation could sensibly return either of the
following results:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>array([0, 1, 2, 3, 4, 5]).reshape(2, 3) --> array([[0, 1, 2], or array([[0, 2, 4],
[3, 4, 5]]) [1, 3, 5]])
</pre></div>
</div>
<p>Both arrays are of the appropriate shape and preserve the ordering of the original sequence of numbers, depending on how you traverse them. The left array preserves the ordering of the original data if you traverse the columns within a row, and then proceed to the next row. This is known as <strong>row-major</strong> ordering. The array on the right preserves the ordering if you traverse the rows within a given column, and then transition to the next column. This is thus referred to as <strong>column-major</strong>
ordering. One ordering is not inherently better than the other. That being said, <em>NumPy always defaults to row-major ordering whenever one of its functions involves array traversal</em>.</p>
<div class="admonition warning">
<p class="admonition-title fa fa-exclamation-circle"><strong>Remember This:</strong></p>
<p>NumPy utilizes row-major ordering, as a default, for any operation that requires an array to be traversed.</p>
</div>
<p>These two orderings are simple enough to follow for a 2D-array, but how do they manifest in arrays with higher dimensions, where we have to worry not only about rows and columns, but potentially “stacks of sheets with rows and columns” (which would be a 4D array) and so on? The generic rules are as follows:</p>
<ul class="simple">
<li><p><strong>Row-major ordering (C ordering) {NumPy’s default}</strong>: traverse an array by advancing the index of the <em>last axis</em>, first, until the end of that axis is reached, and then advance the index of the second-to last axis, and so on.</p></li>
<li><p><strong>Column-major ordering (F ordering)</strong>: traverse an array by advancing the index of the <em>first axis</em>, first, until the end of that axis is reached, and then advance the index of the second axis, and so on.</p></li>
</ul>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>Note</strong>:</p>
<p>“Row-major” ordering is also referred to as “C-ordering” because this is the traversal method utilized in the C language. “Column-major” ordering, on the other hand, is also referred to as “F-ordering”, because it is used by the Fortran language. NumPy functions, like <code class="docutils literal notranslate"><span class="pre">reshape</span></code> allow you to specify either <code class="docutils literal notranslate"><span class="pre">order="C"</span></code> (which is the default) or <code class="docutils literal notranslate"><span class="pre">order="F"</span></code> to control the order in which an array is traversed; these options thus correspond to row-major and column-major ordering.</p>
</div>
<p>To make this more concrete, let’s consider how NumPy reshapes a shape-(24,) array into a shape-(2,3,4) array:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># reshape a shape-(24,) array into a shape-(2,3,4) array</span>
<span class="o">>>></span> <span class="n">np</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="mi">3</span><span class="o">*</span><span class="mi">4</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
<span class="n">array</span><span class="p">([[[</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span>
<span class="p">[</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">],</span>
<span class="p">[</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">]],</span>
<span class="p">[[</span><span class="mi">12</span><span class="p">,</span> <span class="mi">13</span><span class="p">,</span> <span class="mi">14</span><span class="p">,</span> <span class="mi">15</span><span class="p">],</span>
<span class="p">[</span><span class="mi">16</span><span class="p">,</span> <span class="mi">17</span><span class="p">,</span> <span class="mi">18</span><span class="p">,</span> <span class="mi">19</span><span class="p">],</span>
<span class="p">[</span><span class="mi">20</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">22</span><span class="p">,</span> <span class="mi">23</span><span class="p">]]])</span>
</pre></div>
</div>
<p>Following NumPy’s default row-major ordering, we can perform this reshaping by following these steps:</p>
<ol class="arabic simple">
<li><p>Create an empty array of the desired shape: (2, 3, 4).</p></li>
<li><p>Start by inserting the 0th element from the input array into the (0, 0, 0) element of the output array.</p></li>
<li><p>Advance the index by <em>increasing the index of the last axis, first</em>, and inserting the following element from the input array.</p></li>
<li><p>If you reach the end of an axis (axis-2, for instance, only has 4 slots), reset the index for that axis to 0, and advance the index of the preceding axis. Go back to 3.</p></li>
</ol>
<p>This traversal process is easier to understand when laid out explicitly:</p>
<hr class="docutils" />
<p><strong>Reshaping a shape-(24,) array to a shape-(2,3,4) array, using NumPy’s default “row-major” ordering</strong></p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>Input Array Output Array
----------- ---------------
entry: 0 -> entry: (0, 0, 0)
entry: 1 -> entry: (0, 0, 1)
entry: 2 -> entry: (0, 0, 2)
entry: 3 -> entry: (0, 0, 3) *row-0 of sheet 0, filled. go to next row*
entry: 4 -> entry: (0, 1, 0)
entry: 5 -> entry: (0, 1, 1)
entry: 6 -> entry: (0, 1, 2)
entry: 7 -> entry: (0, 1, 3) *row-1 of sheet 0, filled. go to next row*
entry: 8 -> entry: (0, 2, 0)
entry: 9 -> entry: (0, 2, 1)
entry:10 -> entry: (0, 2, 2)
entry:11 -> entry: (0, 2, 3) *row-2 of sheet 0, filled. go to next sheet!*
entry:12 -> entry: (1, 0, 0)
entry:13 -> entry: (1, 0, 1)
entry:14 -> entry: (1, 0, 2)
entry:15 -> entry: (1, 0, 3) *row-0 of sheet 1, filled. go to next row*
entry:16 -> entry: (1, 1, 0)
entry:17 -> entry: (1, 1, 1)
entry:18 -> entry: (1, 1, 2)
entry:19 -> entry: (1, 1, 3) *row-1 of sheet 1, filled. go to next row*
entry:20 -> entry: (1, 2, 0)
entry:21 -> entry: (1, 2, 1)
entry:22 -> entry: (1, 2, 2)
entry:23 -> entry: (1, 2, 3) *row-2 of sheet 1, filled. Done!*
</pre></div>
</div>
<hr class="docutils" />
<p>The same process can be extended to reshape one multidimensional array into another multidimensional array of a different shape. The input and output arrays are simply traversed, respectively, according to “row-major” rules. Suppose we want to reshape a shape-(2,3,4) array into a shape-(6,4) array. This process would be carried out as follows:</p>
<hr class="docutils" />
<p><strong>Reshaping a shape-(2,3,4) into a shape(6,4) array using NumPy’s default “row-major” ordering</strong></p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span> Input Array Output Array
---------------- ---------------
entry: (0, 0, 0) -> entry: (0, 0)
entry: (0, 0, 1) -> entry: (0, 1)
entry: (0, 0, 2) -> entry: (0, 2)
entry: (0, 0, 3) -> entry: (0, 3)
entry: (0, 1, 0) -> entry: (1, 0)
...
...
entry: (1, 2, 3) -> entry: (5, 3)
</pre></div>
</div>
<p>Although this bookkeeping may seem a bit tedious at first glance, you will likely find that you are able to build up enough intuition for row-major ordering, to the point where you never need to write out these tables in full! The ability to reshape an array to adjust the way you can access an array’s data is commonly used in data science applications. Furthermore, understanding how NumPy handles array traversal is critical to understanding more advanced concepts like array-broadcasting and
advanced indexing.</p>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>Reshape is its own inverse</strong>:</p>
<p>According to this discussion, <code class="docutils literal notranslate"><span class="pre">reshape</span></code> can effectively “undo” itself: <code class="docutils literal notranslate"><span class="pre">np.arange(10).reshape(5,2).reshape(10)</span></code> will return <code class="docutils literal notranslate"><span class="pre">array([0,</span> <span class="pre">1,</span> <span class="pre">2,</span> <span class="pre">3,</span> <span class="pre">4,</span> <span class="pre">5,</span> <span class="pre">6,</span> <span class="pre">7,</span> <span class="pre">8,</span> <span class="pre">9])</span></code>. Take some time to consider why this will always be true, no matter how many intermediary reshapes are performed.</p>
</div>
</div>
<div class="section" id="Links-to-Official-Documentation">
<h2>Links to Official Documentation<a class="headerlink" href="#Links-to-Official-Documentation" title="Permalink to this headline"></a></h2>
<ul class="simple">
<li><p><a class="reference external" href="https://numpy.org/doc/stable/glossary.html#term-row-major">Definition of row major ordering</a></p></li>
<li><p><a class="reference external" href="https://numpy.org/doc/stable/glossary.html#term-column-major">Definition of column major ordering</a></p></li>
<li><p><a class="reference external" href="https://numpy.org/doc/stable/reference/routines.indexing.html#iterating-over-arrays">Routines for iterating over arrays</a></p></li>
<li><p><a class="reference external" href="https://numpy.org/doc/stable/reference/arrays.nditer.html#iterating-over-arrays">Detailed description of array iteration</a></p></li>
</ul>
</div>
</div>
</div>
</div>
<footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
<a href="FunctionsForCreatingNumpyArrays.html" class="btn btn-neutral float-left" title="Functions for Creating NumPy Arrays" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
<a href="VectorizedOperations.html" class="btn btn-neutral float-right" title="“Vectorized” Operations: Optimized Computations on NumPy Arrays" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
</div>
<hr/>
<div role="contentinfo">
<p>© Copyright 2021, Ryan Soklaski.</p>
</div>
Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
<a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
provided by <a href="https://readthedocs.org">Read the Docs</a>.
</footer>
</div>
</div>
</section>
</div>
<script>
jQuery(function () {
SphinxRtdTheme.Navigation.enable(true);
});
</script>
</body>
</html>