Merge branch 'master' into sofia/boolean_indexing

Author: sofiiako

Numpy/Array Indexing and Slicing/Indexing Basics/__init__.py

@@ -0,0 +1,17 @@
+type: edu
+files:
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 240
+    length: 7
+    placeholder_text: '# TODO'
+  - offset: 252
+    length: 11
+    placeholder_text: '# TODO'
+- name: tests/test_task.py
+  visible: false
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false

Numpy/Array Indexing and Slicing/Indexing Basics/task-info.yaml

@@ -0,0 +1,73 @@
+## Indexing Basics
+
+Array indexing refers to any use of the square brackets (`[]`) to index array values.
+
+### Single element indexing
+
+Single element indexing for a 1-D array works exactly like that 
+for other standard Python sequences. It is 0-based, and accepts negative indices for 
+indexing from the end of the array.
+
+Unlike lists and tuples, NumPy arrays support multidimensional indexing for multidimensional 
+arrays. That means that **it is not necessary to separate each dimension’s index into its 
+own set of square brackets**.
+
+```python
+x = np.arange(10).reshape(2, 5) # 2-dimensional
+print(x[1, 3])
+print(x[1, -1])
+print(x[0])
+```
+Output:
+```text
+8
+9
+[0, 1, 2, 3, 4]
+```
+Note that `x[0, 2]` and `x[0][2]` will produce the same result, `2`. However, the second case 
+is less efficient as a new temporary array is created after the first index that is subsequently 
+indexed by 2.
+
+### Slicing
+
+It is possible to slice arrays to extract arrays of the same number of dimensions, 
+but of different sizes than the original. The slicing works exactly the same way it 
+does for lists and tuples except that they can be applied to multiple dimensions as well.
+Basic slicing occurs when obj is a slice object (constructed by `start:stop:step` notation inside 
+of brackets), an integer, or a tuple of slice objects and integers.
+
+1-D array:
+```python
+x = np.arange(35)
+print(x[2:15])
+print(x[1:30:5])  # [start:stop:step]
+```
+Output:
+```text
+[ 2  3  4  5  6  7  8  9 10 11 12 13 14]
+[ 1  6 11 16 21 26]
+```
+2-D array:
+```python
+y = x.reshape(5, 7)
+print(y[1:5:2])
+print(y[1:5:2, ::3])  # First slicing in the first dimension, then in the second.
+```
+Output:
+```text
+[[ 7  8  9 10 11 12 13]
+ [21 22 23 24 25 26 27]]
+[[ 7 10 13]
+ [21 24 27]]
+```
+
+These examples show the use of indexing when referencing data in an array. 
+They work just as well when assigning to an array.
+Read more about this topic [here](https://numpy.org/doc/stable/user/basics.indexing.html#basics-indexing).
+
+### Task
+1. Variable `a`: use indexing on the array `x` to extract number `19` from it. Please
+   **do not** just assign `a` the value `19` :)
+2. Variable `b`: use slicing to extract every second element in every second row. The resulting array 
+should have shape `(5, 2)`.
+   

Numpy/Array Indexing and Slicing/Indexing Basics/task.md

@@ -0,0 +1,21 @@
+import numpy as np
+
+x = np.arange(40).reshape(10, 4)
+# Array x:
+# [[ 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]]
+
+a = x[4, 3]
+b = x[::2, ::2]
+
+if __name__ == '__main__':
+    print(a)
+    print(b)

Numpy/Array Indexing and Slicing/Indexing Basics/task.py

@@ -0,0 +1,15 @@
+import unittest
+import numpy as np
+
+from task import a, b, x
+
+
+class TestCase(unittest.TestCase):
+    def test_arrays_shape(self):
+        self.assertEqual(b.shape, (5, 2), msg="Wrong shape of array b")
+        self.assertEqual(type(a), np.int64, msg="a has to be a numpy.int64")
+
+    def test_array_content(self):
+        self.assertEqual(a, 19, msg="a has to be equal to 19")
+        np.testing.assert_array_equal(b, x[::2, ::2], err_msg='Something wrong in array b!')
+

Numpy/Array Indexing and Slicing/Indexing Basics/tests/__init__.py

@@ -0,0 +1,26 @@
+type: edu
+files:
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 63
+    length: 28
+    placeholder_text: '# TODO: use a 1-D numpy array for indexing'
+  - offset: 96
+    length: 52
+    placeholder_text: '# TODO: use a 2-D numpy array for indexing'
+  - offset: 155
+    length: 22
+    placeholder_text: '# TODO: use a 1-D numpy array for indexing'
+  - offset: 182
+    length: 43
+    placeholder_text: '# TODO: use two 1-D arrays for indexing'
+  - offset: 230
+    length: 25
+    placeholder_text: '# TODO: use a 1-D numpy array and a scalar for indexing'
+- name: tests/test_task.py
+  visible: false
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false

Numpy/Array Indexing and Slicing/Indexing Basics/tests/test_task.py

@@ -0,0 +1,90 @@
+## Integer array indexing
+
+NumPy arrays may be indexed with other arrays.
+For all cases of index arrays, what is returned is a copy of the original data, not a view as one gets for slices.
+
+Index arrays must be of integer type. Each value in the array indicates which value in the array 
+to use in place of the index. Negative values are permitted and work as they do with single indices or slices.
+
+```python
+x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+a = np.array([0, 3, 5, 2])
+print(x[a])
+```
+Output:
+```text
+[1 4 6 3]
+```
+
+When index arrays are used, what is returned is an array with the same shape as the index 
+array, but with the type and values of the array being indexed:
+```python
+b = np.array([[9, 9], [0, 1]])
+c = x[b]
+print(c)
+```
+Output:
+```text
+[[10 10]
+ [ 1  2]]
+```
+
+### Indexing multidimensional arrays
+Things become more complex when multidimensional arrays are indexed, particularly with multidimensional index arrays.
+Let's consider this:
+
+```python
+x = np.arange(15).reshape(5, 3)
+print(x)
+print(x[np.array([0, 1, 4])])  # 1
+print(x[np.array([0, 1, 4]), np.array([0, 0, 1])])  # 2
+```
+Output:
+```text
+[[ 0  1  2]
+ [ 3  4  5]
+ [ 6  7  8]
+ [ 9 10 11]
+ [12 13 14]]
+ 
+[[ 0  1  2]
+ [ 3  4  5]
+ [12 13 14]]
+ 
+[ 0  3 13]
+```
+You can see that in the first case, a new array is constructed where 
+each value of the index array selects one row from the indexed array and the resulting 
+array has the shape `(number_of_index_elements, size_of_row)`.
+
+In the second case, the resulting array has the same shape as the index arrays, and the values 
+correspond to the index set for each position in the index arrays. In this example, the first 
+index value is `0` for both index arrays, and thus the first value of the resulting array is `x[0, 0]`. 
+The next value is `y[1, 0]`, and the last is `y[4, 1]`.
+
+If the index arrays do not have the same shape, there is an attempt to broadcast them to the same shape. 
+If they cannot be broadcast to the same shape, an exception is raised.
+
+The broadcasting mechanism permits index arrays to be combined with scalars for other indices. 
+The scalar value is used for all the corresponding values of the index arrays:
+
+```python
+print(x[np.array([0, 2, 3, 4]), 1])
+```
+Output:
+```text
+[ 1  7 10 13]
+```
+You can read more about integer indexing [here](https://numpy.org/doc/stable/reference/arrays.indexing.html#integer-array-indexing).
+
+### Task
+1. Using integer array indexing create an array `a` that contains elements with 
+   indices `[7, 13, 28, 33]` from the array `x`.
+   Then create a 2-D array `b` with shape `(3, 3)` that contains elements with indices
+   `[0, 1, 2], [10, 11, 12], [28, 29, 30]` from the array `x`.
+   
+2. Based on the 2-D array `y`:
+   - Create an array `c` containing rows number `0`, `2` and `4`.
+   - Create a 1-D array `d`, containing elements `0`, `1` and `2` from the rows `0`, `2` and `4`, respectively.
+   - Create a 1-D array `e`, containing elements with index `6` from rows `1`, `2` and `4`.
+    

Numpy/Array Indexing and Slicing/Integer Array Indexing/__init__.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+x = np.arange(35)
+y = x.reshape(5, 7)
+
+a = x[np.array([7, 13, 28, 33])]
+b = x[np.array([[0, 1, 2], [10, 11, 12], [28, 29, 30]])]
+
+
+c = y[np.array([0, 2, 4])]
+d = y[np.array([0, 2, 4]), np.array([0, 1, 2])]
+e = y[np.array([1, 2, 4]), 6]
+
+
+if __name__ == '__main__':
+    print(y)
+    print('\n', a.shape)
+    print('\n', b.shape)
+    print('\n', c.shape)
+    print('\n', d.shape)
+    print('\n', e.shape)