# 043. Comparing Fortran and NumPy syntax
topic: {ref}`arrays`
Used to NumPy?
Many of the Fortran intrinsics to deal with arrays will already be familiar to you.
```{list-table} A bit of Fortran vs NumPy
---
header-rows: 1
widths: 2 2 3
---
* - Fortran
- NumPy equivalent[^np]
- Value
* - ```fortran
integer :: a(2, 3)
```
- ```python
np.empty(
(2, 3),
dtype=np.int32
)
```
- Empty 2x3 array of int32 [^empty] [^order]
* - ```fortran
a = 1
```
- ```python
a[:] = 1
```
- All array elements set to 1 [^np.full] [^setting]
* - ```fortran
size(a)
```
- ```python
a.size
```
- 6
* - ```fortran
shape(a)
```
- ```python
a.shape
```
- (2, 3) [^shape]
* - ```fortran
a(1,1) = 100
```
- ```python
a[0,0] = 100
```
- Element in first row and first column set to 100
* - ```fortran
maxval(a)
```
- ```python
a.max()
```
- 100
* - ```fortran
minval(a)
```
- ```python
a.min()
```
- 1
* - ```fortran
sum(a)
```
- ```python
a.sum()
```
- 105
* - ```fortran
sum(a, dim=1)
```
- ```python
a.sum(axis=0)
```
- (101, 2, 2)
```
[^np]: The NumPy examples assume
```python
import numpy as np
```
[^empty]: In Fortran, the "empty" array may get values set to zero,
but this is not guaranteed (compiler and hardware(?) dependence).
With NumPy, the uninitialized array elements will not (all) be zero.
[^np.full]: With NumPy,
```python
a = np.full((m, n), value, dtype=np.int32)
```
could be used to achieve the result of the first two steps.
[^order]: In Fortran, remember that the array elements are stored in
column-major order.
In NumPy, row-major order is the default, though you can specify
[on creation](https://numpy.org/doc/stable/reference/generated/numpy.empty.html)
or [transform to](https://numpy.org/doc/stable/reference/generated/numpy.asfortranarray.html)
column-major order.
[^setting]: **Notes**
* Fortran supports the shorthand for setting all elements (`a = 1` above),
but if you do that in Python, `a` becomes a single Python integer (`int`).
* Fortran also supports setting all elements with colon syntax,
but you must specify a `:` for each dimension.
* In NumPy, `a[:]` and `a[...]` both work as shorthand for the entire array
regardless of the number of dimensions,
whereas in Fortran we need to give a colon for each dimension: `a(:,:)`.
* For Fortran allocatable arrays, `a = ...` might[^b] re-allocate the array,
whereas explicit `a(:,:) = ...` would not.
[^b]: If it has already been allocated and the RHS is an array with
a different shape from the LHS.
`a = 1` like in our example still just sets all elements to 1.
[^shape]: `shape(a)` (Fortran) returns an integer array,
whereas `a.shape` (NumPy) returns a tuple of Python `int`s
(i.e., not NumPy integers).
---
```{literalinclude} ../../src/cf-numpy.f90
:language: fortran
:caption: cf-numpy.f90 | | 
| 
```
```{code-block} text
:caption: Output[^gfortran-version]
Before setting:
row 1: 0 2103326976 0
col 1: 0 0
After setting:
row 1: 1 1 1
col 1: 1 1
size: 6
shape: 2 3
maxval: 100
minval: 1
sum: 105
sum, dim=1: 101 2 2
sum, dim=2: 102 3
```
[^gfortran-version]: Compiled using `GNU Fortran (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0` with no flags
```{note}
NumPy also provides a functional API that makes it look more like Fortran.
See such comparisons and more here:
```
---