1. Numpy (Numerical Python)
John R. Woodward

2. Introduction Numpy Numeric Python
Fast computation with n-dimensional arrays

3. Numpy Based around one data structure ndarray n-dimensional array
Import with import numpy as np
Usage is np.command(xxx)

4. ndarrays
1d: 5,67,43,76,2,21
a=np.array([5,67,43,76,2,21])
2d: 4,5,8,4
6,3,2,1
8,6,4,3
a=np.array([4,5,8,4],[6,3,2,1],[8,6,4,3])

5. *, + import numpy as np data = randn(2, 3) print data print data * 10
print data + data
[[ ]
[ ]]
[[ ]
[ ]]
[[ ]
[ ]]

6. Shape and dtype OUTPUT (2L, 3L) float64 print data.shape
print data.dtype
Numpy tries to infer the datatype
OUTPUT
(2L, 3L)
float64

7. Creating ndarrays data1 = [6, 7.5, 8, 0, 1] arr1 = np.array(data1)
print arr1
Output
[ ]

8. Multidimensional arrays
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]] arr2 = np.array(data2) print arr2 print arr2.ndim print arr2.shape
OUTPUT
[[ ]
[ ]] 2
(2L, 4L)

9. print arr2
print arr2.ndim
print type(arr2.ndim)
print arr2.shape
print type(arr2.shape)
print arr2.shape[0]
print arr2.shape[1]

10. OUTPUT [[1 2 3 4] [5 6 7 8]] 2 <type 'int'> (2L, 4L)
<type 'tuple'> 4
print arr2
print arr2.ndim
print type(arr2.ndim)
print arr2.shape
print type(arr2.shape)
print arr2.shape[0]
print arr2.shape[1]

11. 3d array data2 = [[[1]]] arr2 = np.array(data2) print arr2
print arr2.ndim
print arr2.shape

12. 3d array OUTPUT [[[1]]] 3 (1L, 1L, 1L) data2 = [[[1]]]
arr2 = np.array(data2)
print arr2
print arr2.ndim
print arr2.shape
OUTPUT
[[[1]]] 3
(1L, 1L, 1L)

13. More making arrays np.zeros(10) np.zeros((3, 6)) np.empty((2, 3, 2))
[ ]
[[ ]
[ ]
[ ]]
[[[ ]
[ ]
[ ]]
[[ ]
[ ]]]
np.zeros(10)
np.zeros((3, 6))
np.empty((2, 3, 2))

14. Operations between arrays and scalars
arr = np.array ([1., 2., 3.])
print arr
print arr * arr
print arr - arr
print 1 / arr
print arr ** 0.5

15. Operations between arrays and scalars
output
[ ]
[ ]
[ ]
[ ]
[ ]
arr = np.array ([1., 2., 3.])
print arr
print arr * arr
print arr - arr
print 1 / arr
print arr ** 0.5

16. Array creation functions

17. a=np.array([True], dtype=np.int64)
print a
print a.dtype
a=np.array([True], dtype=np.bool)

18. [1] Int64 [ True] bool a=np.array([True], dtype=np.int64) print a
print a.dtype
a=np.array([True], dtype=np.bool)
[1]
Int64
[ True]
bool

19. NumPy data types 1

20. NumPy data types 2

21. astype [ 3.7 -1.2 -2.6] [ 3 -1 -2] arr = np.array( [3.7, -1.2, -2.6])
print arr
print arr.astype(np.int32)
note that the data has been truncated.

22. astype - string to float
numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)
print numeric_strings
print numeric_strings.astype(float)
['1.25' '-9.6' '42']
[ ]

23. Basic indexing and slicing (broadcasting)
arr = np.arange(10)
print arr
print arr[5]
print arr[5:8]
arr[5:8] = 12
[ ] 5
[5 6 7]
[ ]

24. The original array has changed
arr_slice = arr[5:8]
arr_slice[1] = 12345
print arr
arr_slice[:] = 64
[ ]
[ ]

25. 2d array [7 8 9] 3 arr2d = np.array ([[1, 2, 3], [4, 5, 6],
[7, 8, 9]])
print arr2d[2]
print arr2d[0][2]
print arr2d[0, 2]
(last two are same)
[7 8 9] 3

26. 3d array [[[ 1 2 3] [ 4 5 6]] [[ 7 8 9] [10 11 12]]] [[1 2 3] [4 5 6]]
[[[ ]
[ ]]
[[ ]
[ ]]]
[[1 2 3]
[4 5 6]]
[ ]]
arr3d = np.array
([[[1, 2, 3],
[4, 5, 6]],
[[7, 8, 9],
[10, 11, 12]]])
print arr3d
print arr3d[0]
print arr3d[1]

27. Indexing with slices – 1D
arr = np.arange(10)
print arr
print arr[1:6]
Output
[ ]
[ ]

28. Indexing with slices – 2D
[[1 2 3]
[4 5 6]
[7 8 9]]
[4 5 6]]
[[2 3]
[5 6]]
arr2d = np.array(
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print arr2d
print arr2d[:2]
print arr2d[:2, 1:]

29. Indexing with slices – 2D
arr2d = np.array(
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print arr2d[1, :2]
print arr2d[2, :1]
print arr2d[:, :1]
[4 5]
[7]
[[1]
[4]
[7]]

30. Fancy indexing indexing using integer arrays arr = np.empty((8, 4))
[[ ]
[ ]
[ ]
[ ]
[ ]
[ ]
[ ]
[ ]]
[[ ]
[ ]
[ ]]
[[ ]
[ ]]
Fancy indexing
indexing using integer arrays
arr = np.empty((8, 4))
for i in range(8):
arr[i] = i
print arr
print arr[[4, 3, 0, 6]]
print arr[[-3, -5, -7]]
Negative index select from the end

31. Transposing arrays and swapping axes
[[ ]
[ ]
[ ]]
(3L, 5L)
[[ ]
[ ]
[ ]
[ ]
[ ]]
(5L, 3L)
Transposing arrays and swapping axes
arr = np.arange(15).reshape((3, 5))
print arr
print arr.shape
print arr.T
print arr.T.shape

32. Inner Product (dot operator)
[[0 1]
[2 3]]
[[0 2]
[1 3]]
[[ 4 6]
[ 6 10]]
[[ 1 3]
[ 3 13]]
arr = np.arange(4).
reshape((2, 2))
print arr
print arr.T
print np.dot(arr.T, arr)
print np.dot(arr, arr.T)

33. Inner Product (dot operator)
arr = np.arange(9).reshape((3, 3))
print arr
print np.dot(arr.T, arr)
[[0 1 2]
[3 4 5]
[6 7 8]]
[[ ]
[ ]
[ ]]

34. arr*arr [[ 0 1 4] [[0 1 2] [ 9 16 25] [3 4 5] [36 49 64]] [6 7 8]]
arr = np.arange(9).reshape((3, 3))
print arr
print arr*arr
[[0 1 2]
[3 4 5]
[6 7 8]]
[[ ]
[ ]
[ ]]

35. Fast element-wise array functions
arr = np.arange(5)
print arr
print np.sqrt(arr)
print np.exp(arr)
[ ]
[ ]
[ ]

36. element-wise maximum x = randn(4) y = randn(4) print x print y
print np.maximum(x, y)
[ ]
[ ]
[ ]

37. element-wise add x = randn(4) y = randn(4) print x print y
print np.add(x, y)
[ ]
[ ]
[ ]