<jupyter_start><jupyter_text>Введение в NumPy ОсновыОсновной объект в Numpy - однородный многомерный массив **ndarray**, представляющий таблицу элементов (как правило, чисел) одного типа, проиндексированных натуральными числами. Размерности массива в Numpy называются осями (**axis**).Добавление библиотеки в проект:<jupyter_code>import numpy as np               # Import numpy
np.__version__<jupyter_output><empty_output><jupyter_text>Создание массивов NumPyНиже представлены различные способы создания массивов. Самый простой - через *list* (список) в Python:<jupyter_code>np.array([1, 2, 3, 4, 5, 6, 7], dtype=np.int16)   # Set type = int16<jupyter_output><empty_output><jupyter_text>С помощью встроенного метода *arange([start,] stop[, step,], dtype=None)*:<jupyter_code>a = np.arange(20, dtype=np.int32).reshape(4, 5)    # Create 2D-array
a<jupyter_output><empty_output><jupyter_text>Обратное преобразование массива в список:<jupyter_code>a.tolist()    # ndarray to list<jupyter_output><empty_output><jupyter_text>Массив обладает различными атрибутами (размерность, длина, тип, размерэлементов):<jupyter_code>a.dtype      # Type of elements
a.shape      # Shape of the array
a.ndim       # Number of dimensions
a.itemsize   # Size of items (for int32 )
a.size       # Number of elements in the array
type(a)      # Python type method<jupyter_output><empty_output><jupyter_text>Numpy позволяет создавать массивы комплексных чисел:<jupyter_code>np.array([1, 2, 3, 4], dtype=complex)<jupyter_output><empty_output><jupyter_text>Массивы с начальными значениямиМожно создавать массивы, заполненные нулями, единицами, случайным мусором или пользовательским значением:<jupyter_code>np.zeros(5, dtype=int)         # Zeros
np.ones((3, 5))                # Ones
np.full(shape=(2,5), fill_value=7, dtype=int)   # Filled with value
np.empty(7)    # Uninitialized array
b = np.empty(5, dtype=int)   # Uninitialized array
b.fill(777)                  # Fill with value
b<jupyter_output><empty_output><jupyter_text>Для создания массива равномерно распределенных в заданном диапазоне чисел используется метод *linspace*:  ```pythonnp.linspace(    start,    stop,    num=50,    endpoint=True,    retstep=False,    dtype=None,    axis=0,)```<jupyter_code>np.linspace(0, 1, 5)<jupyter_output><empty_output><jupyter_text>Единичная матрица, двумерный массив:<jupyter_code>np.eye(5, dtype=int)    # Identity matrix ('I' as eye)<jupyter_output><empty_output><jupyter_text>Математические операции с массивами<jupyter_code>c = np.arange(8).reshape(2,4)
c
c*5     # Multiply
c/10    # Divide
c ^ 7   # XOR (note: reversed array)
c.T     # Transpose<jupyter_output><empty_output><jupyter_text>Различные операции с элементами и срезами<jupyter_code>c[1,:]   # Second row, the same as a[1, ...]
c[:,1]   # Second column, the same as a[..., 1]
c[c>1]   # Boolean for elements
c>1      # Boolean for the array
c.flatten()[::-1]    # Flatten and reverse<jupyter_output><empty_output><jupyter_text>Методы *any* и *all* для булевой проверки элементов в массиве<jupyter_code>np.any(c>2)
np.all(a>2)<jupyter_output><empty_output><jupyter_text>Математические функции и методы<jupyter_code>c.sum()      # Sum of elements
c.max()      # Max value. The same as max(a)
c.min()      # Min value. The same as min(a)
np.sqrt(c)   # Square root
np.round(np.sin(np.pi/2 * c/c.max()), 2)   # Round, sine, pi
np.prod(c, axis=0)   # Product
np.cumsum(c)    # Cumulative sum<jupyter_output><empty_output><jupyter_text>Перебор значений массива<jupyter_code>d = np.arange(15).reshape(3,5)
d<jupyter_output><empty_output><jupyter_text>Проход в цикле по строкам<jupyter_code># Iterating over multidimensional array
for row in d:
    print('Each row * 3: ', 3*row)<jupyter_output>Each row * 3:  [ 0  3  6  9 12]
Each row * 3:  [15 18 21 24 27]
Each row * 3:  [30 33 36 39 42]<jupyter_text>Проход по всем элементам в цикле с помощью итератора:<jupyter_code># Flat is an iterator! Flatten() returns an array
for el in d.flat:
    if el < 8:
        print(el)<jupyter_output>0
1
2
3
4
5
6
7<jupyter_text>**Замечание**: *numpy.flat* - одномерный итератор по массиву. *numpy.flatten()* - возвращает одномерную копию массива. Удобный способ преобразования массива к одномерному виду. Возвращает *view* на объект, а не его копию. Если невозможно вернуть отображение, то создает копию.<jupyter_code>d.reshape(-1)<jupyter_output><empty_output><jupyter_text>Метод *ravel* возвращает одномерный массив<jupyter_code>d.ravel()
# Return a contiguous flattened array. 
# It is equivalent to reshape(-1)<jupyter_output><empty_output><jupyter_text>Метод *flatten* возвращает одномерную копию массива<jupyter_code>d.flatten()
d.flatten() is d.ravel()<jupyter_output><empty_output><jupyter_text>Умножение матриц<jupyter_code>np.random.seed(1)
x = np.array([np.random.randint(1, 10) for i in range(9)]).reshape(3,3)
x
y = np.eye(3, dtype=int) * 2
y<jupyter_output><empty_output><jupyter_text>Оператор * умножает матрицы поэлементно<jupyter_code># Operator * operates elementwise
x*y<jupyter_output><empty_output><jupyter_text>Оператор **@** и метод **dot** вычисляет произведение матриц<jupyter_code># Use @ operator for matrix product 
x @ y
# Use dot function or method
x.dot(y)
np.dot(x, y)<jupyter_output><empty_output><jupyter_text>Преобразование матрицМетод *reshape* возвращает отображение на объект, а метод *resize* изменяет массив на месте (in-place). Методы *transpose* или *.T* возвращают отображение на объект.<jupyter_code>z = np.arange(12)
z
# View of the array
z.reshape(3,4)
# Initial array
z
# In-place change
z.resize(3,4)
z
z.T
z.transpose()<jupyter_output><empty_output><jupyter_text>Объединение массивовМетоды: - *concatenate((a1, a2, ...), axis=0, out=None)*. Объединяет массивы a1, a2 вдоль выбранной оси *axis*. - *vstack(tup), hstack(tup)*. Объединяет массивы по вертикали/горизонтали (по строкам / столбцам) - *stack(arrays, axis=0, out=None)*. Объединяет массивы по выбранной оси axis.<jupyter_code>a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
c = np.array([9, 10, 11, 12])
np.concatenate((a, b), axis=0)  # Concatenate two arrays
np.vstack((a, b, c))   # Vertical stack
np.hstack((a, b, c))   # Horizontal stack (flatten!)
np.stack((a, b, c), axis=0)   # Vertical stack
np.stack((a, b, c), axis=1)   # Horizontal stack (not flatten!)<jupyter_output><empty_output><jupyter_text>Разбиение массивовМетоды: - *vsplit(ary, indices_or_sections)*, разбивает массивы на подмассивы (векторы) вдоль вертикальной оси (по строкам) - *hsplit(ary, indices_or_sections)*. разбивает массивы на подмассивы (векторы) вдоль горизонтальной оси (по столбцам) - *split(ary, indices_or_sections, axis=0)*. разбивает массивы на подмассивы вдоль выбранной осиВсе перечисленные методы возвращают *list* массивов *ndarray*.<jupyter_code>x = np.arange(16.0).reshape(4, 4)
x
np.vsplit(x, 4)   # Vertical split
np.hsplit(x, 2)   # Horizontal split
np.split(x, 2, axis=0)   # Samse as vertical split
np.split(x, 2, axis=1)   # Samse as horizontal split<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12567683100598462, 'fraction_numerical': 0.022513536620119692, 'mean_word_length': 5.553688141923436, 'pattern_counts': {'":': 0, '<': 100, '<?xml version=': 0, '>': 103, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '25', 'dir': 'jupyter-structured-clean-dedup', 'id': '157954', 'license': 'MIT', 'n_tokens_mistral': 3008, 'n_tokens_neox': 3107, 'n_words': 638, 'path': 'numpy/numpy_basic.ipynb', 'repo_name': 'hukenovs/py-tutorial', 'size': '7018'}