<jupyter_start><jupyter_text>Процедуры создания массива(Array creation routines) Единицы и нули(Ones and zeros) Create a new array of 2*2 integers, without initializing entries.<jupyter_code>np.zeros([2,2], int) # возвращает новый массив указанной формы и типа, заполненный нулями<jupyter_output><empty_output><jupyter_text>Let X = np.array([1,2,3], [4,5,6], np.int32). Create a new array with the same shape and type as X.<jupyter_code>X = np.array([[1,2,3], [4,5,6]], np.int32)
np.empty_like(X) # возвращает новый массив без инициированных записей с формой и типом данных указанного массива<jupyter_output><empty_output><jupyter_text>Create a 3-D array with ones on the diagonal and zeros elsewhere.<jupyter_code>np.eye(3) # возвращает двумерный массив у которого все элементы по диагонали равны 1, а все остальные равны 0.<jupyter_output><empty_output><jupyter_text>Create a new array of 3*2 float numbers, filled with ones.<jupyter_code>np.ones([3,2]) # возвращает новый массив указанной формы и типа, заполненный единицами<jupyter_output><empty_output><jupyter_text>Let x = np.arange(4, dtype=np.int64). Create an array of ones with the same shape and type as X.<jupyter_code>x = np.arange(4, dtype=np.int64) # возвращает одномерный массив с равномерно разнесенными значениями внутри заданного интервала
np.ones_like(x) # возвращает новый массив из единиц с формой и типом данных указанного массива<jupyter_output><empty_output><jupyter_text>Create a new array of 3*2 float numbers, filled with zeros.<jupyter_code>np.zeros([3,2]) # возвращает новый массив указанной формы и типа, заполненный нулями<jupyter_output><empty_output><jupyter_text>Let x = np.arange(4, dtype=np.int64). Create an array of zeros with the same shape and type as X.<jupyter_code>x = np.arange(4, dtype=np.int64) # возвращает одномерный массив с равномерно разнесенными значениями внутри заданного интервала
np.zeros_like(x) # возвращает новый массив из нулей с формой и типом данных указанного массива<jupyter_output><empty_output><jupyter_text>Create a new array of 2*5 uints, filled with 6.<jupyter_code>np.full((2, 5),6,dtype=np.uint) # возвращает новый массив указанной формы и типа, заполненный указанным значением<jupyter_output><empty_output><jupyter_text>Let x = np.arange(4, dtype=np.int64). Create an array of 6's with the same shape and type as X.<jupyter_code>x = np.arange(4, dtype=np.int64)
np.full_like(x, 6) # возвращает новый массив все элементы которого равны указанному значению, а форма и тип данных такие же как массива x<jupyter_output><empty_output><jupyter_text>Работа с  существующими объектами(From existing data) Create an array of [1, 2, 3].<jupyter_code>np.array([1,2,3]) # создание массива из списка или кортежа<jupyter_output><empty_output><jupyter_text>Let x = [1, 2]. Convert it into an array.<jupyter_code>x = [1,2]
np.asarray(x) # преобразует последовательность в массив NumPy. Если x итак массив NumPy, не делает ничего<jupyter_output><empty_output><jupyter_text>Let X = np.array([[1, 2], [3, 4]]). Convert it into a matrix.<jupyter_code>X = np.array([[1, 2], [3, 4]])
np.asmatrix(X) # интерпретирует входные данные как матрицу<jupyter_output><empty_output><jupyter_text>Let x = [1, 2]. Conver it into an array of `float`.<jupyter_code>x = [1, 2]
np.asfarray(x) # преобразует тип входного массива к вещественному типу float64<jupyter_output><empty_output><jupyter_text>Let x = np.array([30]). Convert it into scalar of its single element, i.e. 30.<jupyter_code>x = np.array([30])
x.item() # преобразует массив с одним элементом в его скалярный эквивалент<jupyter_output><empty_output><jupyter_text>Let x = np.array([1, 2, 3]). Create a array copy of x, which has a different id from x.<jupyter_code>x = np.array([1, 2, 3])
y = np.copy(x)  # возвращает массив-копию указанного объекта
print(id(x), x)
print(id(y), y)<jupyter_output>2670059036304 [1 2 3]
2670059036144 [1 2 3]<jupyter_text>Числовые диапазоны(Numerical ranges) Create an array of 2, 4, 6, 8, ..., 100.<jupyter_code>np.arange(2, 101, 2) # возвращает одномерный массив с равномерно разнесенными значениями внутри заданного интервала<jupyter_output><empty_output><jupyter_text>Create a 1-D array of 50 evenly spaced elements between 3. and 10., inclusive.<jupyter_code>np.linspace(3,10,50) # возвращает одномерный массив из указанного количества элементов, значения которых равномерно распределенны внутри заданного интервала<jupyter_output><empty_output><jupyter_text>Create a 1-D array of 50 element spaced evenly on a log scale between 3. and 10., exclusive.<jupyter_code>np.logspace(3,10,50,endpoint=False) # возвращает 1-мерный массив из указанного кол-ва элементов, значения которых равномерно распределенны по логарифмической шкале внутри заданного интервала<jupyter_output><empty_output><jupyter_text>Построение матриц(Building matrices) Let X = np.array([[ 0,  1,  2,  3],                  [ 4,  5,  6,  7],                 [ 8,  9, 10, 11]]).                 Get the diagonal of X, that is, [0, 5, 10].<jupyter_code>%%timeit

X = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
np.diagonal(X)  # возвращает указанные диагонали массива<jupyter_output>8.42 µs ± 365 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)<jupyter_text>Create a 2-D array whose diagonal equals [1, 2, 3, 4] and 0's elsewhere.<jupyter_code>np.diagflat([1,2,3,4], k=0) # сжимает входной массив до одной оси и строит из него диагональный массив (k-индекс диагонали)<jupyter_output><empty_output><jupyter_text>Create an array which looks like below.array([[ 0.,  0.,  0.,  0.,  0.],       [ 1.,  0.,  0.,  0.,  0.],       [ 1.,  1.,  0.,  0.,  0.]])<jupyter_code>np.tri(3, M=5, k=-1, dtype='float') # возвращает треугольный массив в котором на заданной диагонали и ниже ее расположены единицы, а выше нее расположены нули<jupyter_output><empty_output><jupyter_text>Create an array which looks like below.array([[ 0,  0,  0],       [ 4,  0,  0],       [ 7,  8,  0],       [10, 11, 12]])<jupyter_code>X = np.arange(1,13).reshape(4,3)
np.tril(X,-1) # преобразует указанный массив в треугольный у которого все элементы выше указанной диагонали равны 0.<jupyter_output><empty_output><jupyter_text>Create an array which looks like below. array([[ 1,  2,  3],       [ 4,  5,  6],       [ 0,  8,  9],       [ 0,  0, 12]])<jupyter_code>X = np.arange(1,13).reshape(4,3)
np.triu(X,-1) # преобразует указанный массив в треугольный у которого все элементы ниже указанной диагонали равны 0<jupyter_output><empty_output><jupyter_text>Процедуры изменения массивов(Array manipulation routines) Q1. Let x be a ndarray [10, 10, 3] with all elements set to one. Reshape x so that the size of the second dimension equals 150.<jupyter_code>x=np.array([10,10,3]) 
np.ones(x).reshape(2,150) # возвращает новый массив указанной формы и типа, заполненный единицами<jupyter_output><empty_output><jupyter_text>Q2. Let x be array [[1, 2, 3], [4, 5, 6]]. Convert it to [1 4 2 5 3 6].<jupyter_code>x=np.array([[1,2,3],[4,5,6]])
y=np.ravel(x, order='F') # возвращает сжатый до одной оси массив.
print(y)<jupyter_output>[1 4 2 5 3 6]<jupyter_text>Q3. Let x be array [[1, 2, 3], [4, 5, 6]]. Get the 5th element.<jupyter_code>x=np.array([[1,2,3],[4,5,6]])
x.flat[4] # перебирает элементы массива так, словно он сжат до одной оси.<jupyter_output><empty_output><jupyter_text>Q4. Let x be an arbitrary 3-D array of shape (3, 4, 5). Permute the dimensions of x such that the new shape will be (4,3,5).<jupyter_code>x = np.empty((3, 4, 5))
y = np.swapaxes(x, 1, 0) # меняет местами оси массива
y.shape<jupyter_output><empty_output><jupyter_text>Q5. Let x be an arbitrary 2-D array of shape (3, 4). Permute the dimensions of x such that the new shape will be (4,3).<jupyter_code>x = np.empty((3, 4))
y = x.T # возвращает транспонированный массив (переворачивает оси в массиве)
y.shape<jupyter_output><empty_output><jupyter_text>Q5. Let x be an arbitrary 2-D array of shape (3, 4). Insert a nex axis such that the new shape will be (3, 1, 4).<jupyter_code>x = np.empty((3,4))
y = np.expand_dims(x, axis=1) # добавляет новую ось к массиву. Длинна новой оси всегда равна 1.
y.shape<jupyter_output><empty_output><jupyter_text>Q6. Let x be an arbitrary 3-D array of shape (3, 4, 1). Remove a single-dimensional entries such that the new shape will be (3, 4).<jupyter_code>x = np.empty((3,4,1))
y = np.squeeze(x, axis = 2) # удаляет оси с одним элементом (длинной 1), но не сами элементы массива.
y.shape<jupyter_output><empty_output><jupyter_text>Q7. Lex x be an array [[ 1 2 3][ 4 5 6].and y be an array [[ 7 8 9][10 11 12]].Concatenate x and y so that a new array looks like [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]].<jupyter_code>x = np.array([[1,2,3],[4,5,6]])
y = np.array([[7,8,9],[10,11,12]])
np.concatenate([x,y],1) # соединяет массивы вдоль указанной оси<jupyter_output><empty_output><jupyter_text>Q8. Lex x be an array [[ 1 2 3][ 4 5 6].and y be an array [[ 7 8 9][10 11 12]].Concatenate x and y so that a new array looks like [[ 1  2  3] [ 4  5  6] [ 7  8  9] [10 11 12]]<jupyter_code>x = np.array([[1,2,3],[4,5,6]])
y = np.array([[7,8,9],[10,11,12]])
np.concatenate([x,y],0) # соединяет массивы вдоль указанной оси<jupyter_output><empty_output><jupyter_text>Q8. Let x be an array [1 2 3] and y be [4 5 6]. Convert it to [[1, 4], [2, 5], [3, 6]].<jupyter_code>x = np.array([[1,2,3]])
y = np.array([[4,5,6]])
np.concatenate([x,y],0).T # соединили массивы вдоль указанной оси и провели транспонирование<jupyter_output><empty_output><jupyter_text>Q9. Let x be an array [[1],[2],[3]] and y be [[4], [5], [6]]. Convert x to [[[1, 4]], [[2, 5]], [[3, 6]]].<jupyter_code>x = np.array([[1],[2],[3]])
y = np.array([[4],[5],[6]])
np.concatenate([x,y],1) # соединяет массивы вдоль указанной оси<jupyter_output><empty_output><jupyter_text>Q10. Let x be an array [1, 2, 3, ..., 9]. Split x into 3 arrays, each of which has 4, 2, and 3 elements in the original order.<jupyter_code>x = np.arange(1,10)
np.array_split(x,[4,6]) # разбивает массив на несколько подмассивов<jupyter_output><empty_output><jupyter_text>Q11. Let x be an array[[[  0.,   1.,   2.,   3.],  [  4.,   5.,   6.,   7.]],  [[  8.,   9.,  10.,  11.],  [ 12.,  13.,  14.,  15.]]].Split it into two such that the first array looks like[[[  0.,   1.,   2.],  [  4.,   5.,   6.]],  [[  8.,   9.,  10.],  [ 12.,  13.,  14.]]].  and the second one look like:  [[[  3.],  [  7.]],  [[  11.],  [ 15.]]].<jupyter_code>x = np.arange(16).reshape(2, 2, 4) # записываем в 1-мерный массив числа до 16, а затем меняем форму массива
np.split(x,[3],axis=2) # разбивает массив на несколько подмассивов<jupyter_output><empty_output><jupyter_text>Q12. Let x be an array [[  0.,   1.,   2.,   3.], [  4.,   5.,   6.,   7.], [  8.,   9.,  10.,  11.], [ 12.,  13.,  14.,  15.]].Split it into two arrays along the second axis.<jupyter_code>x = np.arange(16).reshape(4,4) # записываем в 1-мерный массив числа до 16, а затем меняем форму массива
np.split(x,[2],axis=1) # разбивает массив на несколько подмассивов<jupyter_output><empty_output><jupyter_text>Q13. Let x be an array [[  0.,   1.,   2.,   3.], [  4.,   5.,   6.,   7.], [  8.,   9.,  10.,  11.], [ 12.,  13.,  14.,  15.]].Split it into two arrays along the first axis.<jupyter_code>x = np.arange(16).reshape(4,4) # записываем в 1-мерный массив числа до 16, а затем меняем форму массива
np.split(x,[2],axis=0) # разбивает массив на несколько подмассивов<jupyter_output><empty_output><jupyter_text>Q14. Let x be an array [0, 1, 2]. Convert it to [[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]].<jupyter_code>x = np.arange(3) # записываем в 1-мерный массив числа до 3
np.tile(x,4).reshape([2,6]) # создаем массив повторением указанного массива x заданным количеством раз, затем меняем форму массива<jupyter_output><empty_output><jupyter_text>Q15. Let x be an array [0, 1, 2]. Convert it to [0, 0, 1, 1, 2, 2].<jupyter_code>x = np.arange(3) # записываем в 1-мерный массив числа до 3
np.repeat(x,2) # повторяет элементы массива<jupyter_output><empty_output><jupyter_text>Q16. Let x be an array [0, 0, 0, 1, 2, 3, 0, 2, 1, 0].remove the leading the trailing zeros.<jupyter_code>x = np.array([0,0,0,1,2,3,0,2,1,0])
np.trim_zeros(x, trim='fb') # удаляет нули из начала или конца указанного одномерного массива или последовательности.<jupyter_output><empty_output><jupyter_text>Q17. Let x be an array [2, 2, 1, 5, 4, 5, 1, 2, 3]. Get two arrays of unique elements and their counts.<jupyter_code>x = np.array([2,2,1,5,4,5,1,2,3])
np.unique(x, return_counts=True) # находит уникальные элементы массива и возвращает их в отсортированном массиве<jupyter_output><empty_output><jupyter_text>Q18. Lex x be an array [[ 1 2] [ 3 4].Flip x along the second axis.<jupyter_code>x=np.arange(1,5).reshape(2,2)
np.flip(x, axis=1) # располагает элементы в обратном порядке вдоль указанной оси, при этом размеры массива не изменяются<jupyter_output><empty_output><jupyter_text>Q19. Lex x be an array [[ 1 2] [ 3 4].Flip x along the first axis.<jupyter_code>x=np.arange(1,5).reshape(2,2)
np.flip(x, axis=0) # располагает элементы в обратном порядке вдоль указанной оси, при этом размеры массива не изменяются<jupyter_output><empty_output><jupyter_text>Q20. Lex x be an array [[ 1 2] [ 3 4].Rotate x 90 degrees counter-clockwise.<jupyter_code>x=np.arange(1,5).reshape(2,2)
np.rot90(x) # поворачивает массив на 90 градусов по часовой сстрелке в плоскости указанных осей<jupyter_output><empty_output><jupyter_text>Q21 Lex x be an array [[ 1 2 3 4] [ 5 6 7 8].Shift elements one step to right along the second axis.<jupyter_code>x=np.arange(1,9).reshape(2,4)
np.roll(x,1,axis=1) # циклическое смещение элементов массива вдоль указанной оси<jupyter_output><empty_output><jupyter_text>Строковые операции(String operations) Q1. Concatenate x1 and x2.<jupyter_code>x1 = np.array(['Hello', 'Say'], dtype=np.str)
x2 = np.array([' world', ' something'], dtype=np.str)
np.char.add(x1,x2) # поэлементная конкатенация строк<jupyter_output><empty_output><jupyter_text>Q2. Repeat x three time element-wise.<jupyter_code>x = np.array(['Hello ', 'Say '], dtype=np.str)
np.char.multiply(x,3) # поэлементное произведение строк<jupyter_output><empty_output><jupyter_text>Q3-1. Capitalize the first letter of x element-wise.Q3-2. Lowercase x element-wise.Q3-3. Uppercase x element-wise.Q3-4. Swapcase x element-wise.Q3-5. Title-case x element-wise.<jupyter_code>x = np.array(['heLLo woRLd', 'Say sOmething'], dtype=np.str)
capitalized = np.char.capitalize(x) # каждый элемент начинается с большой буквы, остальные буквы строчные
lowered = np.char.lower(x) # все буквы строчные
uppered = np.char.upper(x) # все буквы заглавные
swapcased = np.char.swapcase(x) # поменять заглавные на строчные и наоборот
titlecased = np.char.title(x) # каждое слово начинается с заглавной
print("capitalized =", capitalized)
print("lowered =", lowered)
print("uppered =", uppered)
print("swapcased =", swapcased)
print("titlecased =", titlecased)<jupyter_output>capitalized = ['Hello world' 'Say something']
lowered = ['hello world' 'say something']
uppered = ['HELLO WORLD' 'SAY SOMETHING']
swapcased = ['HEllO WOrlD' 'sAY SoMETHING']
titlecased = ['Hello World' 'Say Something']<jupyter_text>Q4. Make the length of each element 20 and the string centered / left-justified / right-justified with paddings of `_`.<jupyter_code>x = np.array(['hello world', 'say something'], dtype=np.str)
centered = np.char.center(x,20,fillchar="_") # выравниваем строки по центру, задавая кол-во символов в строке 20 ('_'-заполнитель пустоты, ' '-по умолч.)
left = np.char.ljust(x,20,fillchar="_") # выравниваем строки к началу, задавая кол-во символов в строке 20 ('_'-заполнитель пустоты, ' '-по умолч.)
right = np.char.rjust(x,20,fillchar="_") # выравниваем строки к концу, задавая кол-во символов в строке 20 ('_'-заполнитель пустоты, ' '-по умолч.)

print("centered =", centered)
print("left =", left)
print("right =", right)<jupyter_output>centered = ['____hello world_____' '___say something____']
left = ['hello world_________' 'say something_______']
right = ['_________hello world' '_______say something']<jupyter_text>Q5. Encode x in cp500 and decode it again.<jupyter_code>x = np.array(['hello world', 'say something'], dtype=np.str)
encoded = np.char.encode(x, 'cp500') # кодируем строки в указанный формат
decoded = np.char.decode(encoded,'cp500') # декодируем строки в юникод из указанного формата
print("encoded =", encoded)
print("decoded =", decoded)<jupyter_output>encoded = [b'\x88\x85\x93\x93\x96@\xa6\x96\x99\x93\x84'
 b'\xa2\x81\xa8@\xa2\x96\x94\x85\xa3\x88\x89\x95\x87']
decoded = ['hello world' 'say something']<jupyter_text>Q6. Insert a space between characters of x.<jupyter_code>x = np.array(['hello world', 'say something'], dtype=np.str)
np.char.join(' ',x) # Вывод, в котором отдельные символы объединяются указанным символом-разделителем<jupyter_output><empty_output><jupyter_text>Q7-1. Remove the leading and trailing whitespaces of x element-wise.Q7-2. Remove the leading whitespaces of x element-wise.Q7-3. Remove the trailing whitespaces of x element-wise.<jupyter_code>x = np.array(['   hello world   ', '\tsay something\n'], dtype=np.str)
stripped = np.char.strip(x) # возвращает копию массива, где в начале и конце каждого элемента убраны пробелы и табуляция
lstripped = np.char.lstrip(x) # возвращает копию массива, где в начале каждого элемента убраны пробелы и табуляция
rstripped = np.char.rstrip(x) # возвращает копию массива, где в конце каждого элемента убраны пробелы и табуляция
print("stripped =", stripped)
print("lstripped =", lstripped)
print("rstripped =", rstripped)<jupyter_output>stripped = ['hello world' 'say something']
lstripped = ['hello world   ' 'say something\n']
rstripped = ['   hello world' '\tsay something']<jupyter_text>Q8. Split the element of x with spaces.<jupyter_code>x = np.array(['Hello my name is John'], dtype=np.str)
np.char.split(x,' ') # Разбивает на подстроки по указанному элементу<jupyter_output><empty_output><jupyter_text>Q9. Split the element of x to multiple lines.<jupyter_code>x = np.array(['Hello\n\nmy name is John'], dtype=np.str)
np.char.splitlines(x) # возвращает копию массива, разделенную по границам строк<jupyter_output><empty_output><jupyter_text>Q10. Make x a numeric string of 4 digits with zeros on its left.<jupyter_code>x = np.array(['34'], dtype=np.str)
np.char.zfill(x,4) # возвращает строку указанного размера, где пропуски заполнены нулями (выравнивание по концу строки)<jupyter_output><empty_output><jupyter_text>Q11. Replace "John" with "Jim" in x.<jupyter_code>x = np.array(['Hello my name is John'], dtype=np.str)
np.char.replace(x,'John','Jim') # заменяет в указанном массиве указанную подстроку, на др. указанное значение<jupyter_output><empty_output><jupyter_text>Сравнение(Comparison) Q12. Return x1 == x2, element-wise.<jupyter_code>x1 = np.array(['Hello', 'my', 'name', 'is', 'John'], dtype=np.str)
x2 = np.array(['Hello', 'my', 'name', 'is', 'Jim'], dtype=np.str)
np.char.equal(x1,x2) # возвращает результат поэлементного сравнения массивов<jupyter_output><empty_output><jupyter_text>Q13. Return x1 != x2, element-wise.<jupyter_code>x1 = np.array(['Hello', 'my', 'name', 'is', 'John'], dtype=np.str)
x2 = np.array(['Hello', 'my', 'name', 'is', 'Jim'], dtype=np.str)
np.char.not_equal(x1,x2) # возвращает инвертированный результат поэлементного сравнения массивов<jupyter_output><empty_output><jupyter_text>Строковая информация(String information) Q14. Count the number of "l" in x, element-wise.<jupyter_code>x = np.array(['Hello', 'my', 'name', 'is', 'Jimy'], dtype=np.str)
np.char.count(x,'my') # выводит кол-во указанных подстрок в массиве х поэлементно<jupyter_output><empty_output><jupyter_text>Q15. Count the lowest index of "l" in x, element-wise.<jupyter_code>x = np.array(['Hello', 'my', 'name', 'is', 'Jimy'], dtype=np.str)
np.char.find(x, 'm') # ищет индекс указанной подстроки ("-1"-не найдено, выводит результ. 1 совпадения)<jupyter_output><empty_output><jupyter_text>Q16-1. Check if each element of x is composed of digits only.Q16-2. Check if each element of x is composed of lower case letters only.Q16-3. Check if each element of x is composed of upper case letters only.<jupyter_code>x = np.array(['Hello', 'I', 'am', '20', 'years', 'old'], dtype=np.str)
out1 = np.char.isdigit(x) # поэлементная проверка массива на наличие только цифр
out2 = np.char.islower(x) # поэлементная проверка массива на наличие только строчных букв
out3 = np.char.isupper(x) # поэлементная проверка массива на наличие только заглавных букв
print("Digits only =", out1)
print("Lower cases only =", out2)
print("Upper cases only =", out3)<jupyter_output>Digits only = [False False False  True False False]
Lower cases only = [False False  True False  True  True]
Upper cases only = [False  True False False False False]<jupyter_text>Q17. Check if each element of x starts with "hi".<jupyter_code>x = np.array(['he', 'his', 'him', 'his'], dtype=np.str)
np.char.startswith(x,'hi') # поэлементная проверка массива на начало с указанной подстроки<jupyter_output><empty_output><jupyter_text>Numpy вызов функции help(Numpy specific help functions) Q1. Search for docstrings of the numpy functions on linear algebra.<jupyter_code>np.lookfor('linear algebra') # поиск инфы по указанному ключ. слову в документации<jupyter_output>Search results for 'linear algebra'
-----------------------------------
numpy.matrix
    .. note:: It is no longer recommended to use this class, even for linear
numpy.linalg.solve
    Solve a linear matrix equation, or system of linear scalar equations.
numpy.poly
    Find the coefficients of a polynomial with the given sequence of roots.
numpy.einsum
    einsum(subscripts, *operands, out=None, dtype=None, order='K',
numpy.linalg.eig
    Compute the eigenvalues and right eigenvectors of a square array.
numpy.linalg.cond
    Compute the condition number of a matrix.
numpy.linalg.eigh
    Return the eigenvalues and eigenvectors of a complex Hermitian
numpy.linalg.pinv
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
numpy.linalg.LinAlgError
    Generic Python-exception-derived object raised by linalg functions.
numpy.core._multiarray_umath.c_einsum
    c_einsum(subscripts, *operands, out=None, dtype=None, order='K',<jupyter_text>Q2. Get help information for numpy dot function.<jupyter_code>np.info(np.dot) # Получение справочную информацию для функции, класса или модуля.<jupyter_output>dot(*args, **kwargs)

dot(a, b, out=None)

Dot product of two arrays. Specifically,

- If both `a` and `b` are 1-D arrays, it is inner product of vectors
  (without complex conjugation).

- If both `a` and `b` are 2-D arrays, it is matrix multiplication,
  but using :func:`matmul` or ``a @ b`` is preferred.

- If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`
  and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.

- If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
  the last axis of `a` and `b`.

- If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
  sum product over the last axis of `a` and the second-to-last axis of `b`::

    dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

Parameters
----------
a : array_like
    First argument.
b : array_like
    Second argument.
out : ndarray, optional
    Output argument. This must have the exact kind that would be returned
    if it was not used. In particular, it mus[...]<jupyter_text>Ввод и вывод(Input and Output)<jupyter_code>print(date.today())<jupyter_output>2020-04-23<jupyter_text>NumPy бинарные файлы (NPY, NPZ)(NumPy binary files (NPY, NPZ)) Q1. Save x into `temp.npy` and load it.<jupyter_code>x = np.arange(10)
file_name = 'temp.npy' # задаем название файла, 
np.save(file_name, x) # сохраняет массив в двоичном файле формата npy.
y = np.load(file_name) # загружает массивы из файлов формата .npy или .npz, а также pickle объектов и pickle файлов.

np.array_equal(x,y) # вывод результата сравнения массивов<jupyter_output><empty_output><jupyter_text>Q2. Save x and y into a single file 'temp.npz' and load it.<jupyter_code>x = np.arange(10)
y = np.arange(11, 20)
np.savez('temp.npz', x=x,y=y) # cохраняет нескольких массивов в несжатом .npz файле (в формате, похожем на словарь)

z = np.load('temp.npz')
for key in z:
    print ('{}:{}'.format(key, z[key]))

print(np.array_equal(x, z['x'])) # вывод результата сравнения массивов по форме и элементам
print(np.array_equal(y, z['y'])) # вывод результата сравнения массивов по форме и элементам<jupyter_output>x:[0 1 2 3 4 5 6 7 8 9]
y:[11 12 13 14 15 16 17 18 19]
True
True<jupyter_text>Текстовые файлы(Text files) Q3. Save x to 'temp.txt' in string format and load it.<jupyter_code>x = np.arange(10).reshape(2, 5)
header = 'num1 num2 num3 num4 num5'
np.savetxt('temp.txt',x) # сохраняет массив в текстовый файл (1 или 2-х мерный массив NumPy или подобный массиву объект)
np.loadtxt('temp.txt') # выводит массив из текстового файла<jupyter_output><empty_output><jupyter_text>Q4. Save `x`, `y`, and `z` to 'temp.txt' in string format line by line, then load it.<jupyter_code>x = np.arange(10)
y = np.arange(11, 21)
z = np.arange(22, 32)
np.savetxt('temp.txt',(x,y,z)) # сохраняет массивы в текстовый файл, каждый с новой строки
file = np.loadtxt('temp.txt') # выводит массив из текстового файла
file, file[0] # можно обращаться к опред. элементу массива через индекс<jupyter_output><empty_output><jupyter_text>Q5. Convert `x` into bytes, and load it as array.<jupyter_code>x = np.array([1, 2, 3, 4])
x_bytes = x.tostring() # конвертация массива в побайтовую строку
print(x_bytes)
x2 = np.frombuffer(x_bytes, dtype=x.dtype) # интерпретирует буфер как одномерный массив (dtype=int)
print(np.array_equal(x,x2))<jupyter_output>b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00'
True<jupyter_text>Q6. Convert `a` into an ndarray and then convert it into a list again.<jupyter_code>a = [[1, 2], [3, 4]]
x = np.array(a) # создание ndarray из данного списка
a2 = x.tolist() # преобразует массив NumPy в список Python
print(a==a2)<jupyter_output>True<jupyter_text>Форматирование строк(String formatting) Q7. Convert `x` to a string, and revert it.<jupyter_code>x = np.arange(10).reshape(2,5)
x_str = str(x) # преобразуем массив в строку
# print(x_str, "\n", type(x_str))

x_str = x_str.replace('[','').replace(']','') # [] убираем из строки
x2 = np.fromstring(x_str, dtype=x.dtype, sep=" ") # создает новый одномерный массив, который заполнен данными из указанной строки
x2.reshape(x.shape) # предаём форму исходного массива<jupyter_output><empty_output><jupyter_text>Параметры форматирования текста(Text formatting options) Q8. Print `x` such that all elements are displayed with precision=1, no suppress.<jupyter_code>x = np.random.uniform(size=[10,100]) # создание массива указанной размерности с выборкой из равномерного распределения
np.set_printoptions(precision=1, suppress=True) # позволяет настроить параметры вывода массивов на экран ("precision"-кол-во знаков после запятой; "suppress"-показывать полотно целиком или скрывать)
print('размерность :{} \nмассив{}'.format(x.shape,x))<jupyter_output>размерность :(10, 100) 
массив[[0.4 0.2 0.5 0.8 0.5 0.6 0.1 0.3 0.8 0.5 0.9 0.7 0.6 0.7 0.5 0.8 0.1 0.8
  0.6 0.5 0.5 1.  0.3 0.9 0.6 0.4 0.3 0.9 0.4 0.7 0.8 0.7 0.9 0.7 1.  0.
  0.4 0.8 0.4 0.4 0.4 0.8 0.8 0.7 0.5 0.1 0.9 0.1 0.5 1.  0.1 0.9 0.9 0.7
  0.3 0.1 0.7 0.5 0.6 0.3 0.6 0.8 0.9 1.  0.6 0.7 0.4 0.9 1.  0.2 0.8 0.5
  0.4 0.9 0.6 0.  0.7 0.1 0.9 0.9 0.2 0.1 0.2 0.1 0.5 0.  0.7 0.8 0.9 0.1
  0.9 0.1 0.1 0.3 0.9 0.5 0.5 0.4 0.3 0.3]
 [0.2 0.6 0.1 0.4 0.4 0.3 0.7 0.5 0.  0.3 0.4 0.7 0.3 0.5 0.2 0.8 0.6 0.2
  0.2 0.5 0.  0.9 0.9 0.7 0.8 0.3 0.7 0.7 0.3 0.4 0.  0.3 0.2 0.2 0.7 0.2
  0.2 0.1 0.6 0.9 0.5 0.7 0.  0.9 0.9 0.1 0.4 1.  0.6 0.2 0.6 0.6 0.5 0.1
  0.4 0.3 0.9 0.5 0.1 0.7 0.5 0.8 0.6 0.2 0.8 0.5 0.4 0.5 0.1 0.6 0.5 0.4
  0.1 0.5 0.9 0.5 0.4 0.  0.7 0.2 0.8 0.6 0.2 0.9 0.4 1.  0.6 0.3 0.6 0.1
  0.8 0.1 0.2 0.6 0.8 0.5 0.5 0.9 0.9 0.4]
 [0.1 0.9 0.9 0.5 0.  1.  0.4 0.8 0.6 0.8 0.8 0.1 0.8 0.4 0.5 1.  0.6 0.4
  0.5 0.1 0.1 0.4 0.8 0.9 0.9 0.8 1.  0.2 0.9 0.8 0.7 0.8 0.6 0.8 0.5 0[...]<jupyter_text>n-мерные представления(Base-n representations) Q9. Convert 12 into a binary number in string format.<jupyter_code>bin(12)[2:] # вывод 10-чного числа в бинарном формате<jupyter_output><empty_output><jupyter_text>Q10. Convert 12 into a hexadecimal number in string format.<jupyter_code>hex(12)[2:] # вывод 10-ичного числа в 16-ричном формате<jupyter_output><empty_output><jupyter_text>Линейная алгебра(Linear algebra)  Матричные и векторные представления(Matrix and vector products) Q1. Predict the results of the following code.<jupyter_code>x = [1,2]
y = [[4, 1], [2, 2]]
print(x,'|',y)
print('{} - "np.dot": вычисляет скалярное произведение двух массивов'.format(np.dot(x, y))) # вычисляет скалярное произведение двух массивов
print('{} - "np.dot": вычисляет скалярное произведение двух массивов (строку х с каждым столбцом у)'.format(np.dot(y, x))) # вычисляет скалярное произведение двух массивов (строку х с каждым столбцом у)
print('{} - "np.matmul": вычисляет матричное произведение двух массивов'.format(np.matmul(x, y))) # вычисляет матричное произведение двух массивов
print('{} - "np.matmul": вычисляет матричное произведение двух массивов (строку х с каждым столбцом у)'.format(np.matmul(y,x))) # вычисляет матричное произведение двух массивов (строку х с каждым столбцом у)
print('{} - "np.inner": сумма произведений по последним осям'.format(np.inner(x, y))) # сумма произведений по последним осям
print('{} - "np.inner": сумма произведений по последним осям'.format(np.inner(y, x))) # сумма произведений по последним осям<jupyter_output>[1, 2] | [[4, 1], [2, 2]]
[8 5] - "np.dot": вычисляет скалярное произведение двух массивов
[6 6] - "np.dot": вычисляет скалярное произведение двух массивов (строку х с каждым столбцом у)
[8 5] - "np.matmul": вычисляет матричное произведение двух массивов
[6 6] - "np.matmul": вычисляет матричное произведение двух массивов (строку х с каждым столбцом у)
[6 6] - "np.inner": сумма произведений по последним осям
[6 6] - "np.inner": сумма произведений по последним осям<jupyter_text>Q2. Predict the results of the following code.<jupyter_code>x = [[1, 0], [0, 1]]
y = [[4, 1], [2, 2], [1, 1]]
print(np.dot(y, x))
print(np.matmul(y, x))<jupyter_output>[[4 1]
 [2 2]
 [1 1]]
[[4 1]
 [2 2]
 [1 1]]<jupyter_text>Q3. Predict the results of the following code.<jupyter_code>x = np.array([[1, 4], [5, 6]])
y = np.array([[4, 1], [2, 2]])
print(np.vdot(x, y)) # вычисляет cкалярное произведение двух векторов в том числе и комплексных(a1*b1+a2*b2+...+an*bn)
print(np.vdot(y, x)) # вычисляет cкалярное произведение двух векторов в том числе и комплексных(a1*b1+a2*b2+...+an*bn)
print(np.dot(x.flatten(), y.flatten())) # вычисляет cкалярное произведение двух векторов, получившихся из матриц
print(np.inner(x.flatten(), y.flatten())) # сумма произведений по осям векторов
print()
print((x*y),'\n',(x*y).sum())<jupyter_output>30
30
30
30

[[ 4  4]
 [10 12]] 
 30<jupyter_text>Q4. Predict the results of the following code.<jupyter_code>x = np.array(['a', 'b'], dtype=object)
y = np.array([1, 2])
print(np.inner(x, y)) # сумма произведений по последним осям векторов
print(np.inner(y, x)) # сумма произведений по последним осям векторов
print(np.outer(x, y)) # вычисляет внешнее произведение двух векторов (здесь х-столбцы)
print(np.outer(y, x)) # # вычисляет внешнее произведение двух векторов (здесь х-строки)<jupyter_output>abb
abb
[['a' 'aa']
 ['b' 'bb']]
[['a' 'b']
 ['aa' 'bb']]<jupyter_text>Разложения матриц(Decompositions) Q5. Get the lower-trianglular `L` in the Cholesky decomposition of x and verify it.<jupyter_code>x = np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]], dtype=np.int32)
L = np.linalg.cholesky(x) # выполняет разложение Холецкого
L<jupyter_output><empty_output><jupyter_text>Q6. Compute the qr factorization of x and verify it.<jupyter_code>x = np.array([[12, -51, 4], [6, 167, -68], [-4, 24, -41]], dtype=np.float32)
q,r = np.linalg.qr(x) # выполняет QR-разложение матрицы

'''
Данное разложение позволяет представить матрицу x в виде произведения qr,
где q - это ортогональная (унитарная) матрица, а r - это верхнетреугольная матрица
'''

print('q={}\n\nr={}'.format(q,r))
assert np.allclose(np.dot(q, r), x) # проверка выполнения условия путем перемножения q на r и сравнения с х ПОЭЛЕМЕНТНО!<jupyter_output>q=[[-0.9  0.4  0.3]
 [-0.4 -0.9 -0. ]
 [ 0.3 -0.2  0.9]]

r=[[ -14.  -21.   14.]
 [   0. -175.   70.]
 [   0.    0.  -35.]]<jupyter_text>Q7. Factor x by Singular Value Decomposition and verify it.<jupyter_code>x = np.array([[1, 0, 0, 0, 2], [0, 0, 3, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0]], dtype=np.float32)
U,s,V = np.linalg.svd(x, full_matrices=False ) # выполняет сингулярное (SVD) разложение ('full_matrices'-определяет форму выходных массивов

'''
x - матрица, размерностью (m,n)
U - ортогональная(унитарные для комплексных х) матрица, которая состоит из левых сингулярных векторов (один из размеров будет равен m)
s - диагональная матрица размером (m, n), которая содержит сингулярные числа исходной матрицы х.
V - ортогональная(унитарные для комплексных х) транспонированная матрица, которая состоит из правых сингулярных векторов (один из размеров будет равен n)

Для проверки условия:
1) s_d = np.diag(s) - превращает s из вектора в диагональную матрицу
2) перемножаем матрицы step_2 = s_d и V
3) перемножаем матрицы step_3 = U и step_2
'''

print('U=\n{}\n\ns=\n{}\n\nV=\n{}'.format(U,s,V))
assert np.allclose(np.dot(U, np.dot(np.diag(s), V)), x) # проверка выполнения условия<jupyter_output>U=
[[ 0.  1.  0.  0.]
 [ 1.  0.  0.  0.]
 [ 0.  0.  0. -1.]
 [ 0.  0.  1.  0.]]

s=
[3.  2.2 2.  0. ]

V=
[[-0.   0.   1.   0.   0. ]
 [ 0.4  0.   0.   0.   0.9]
 [-0.   1.   0.   0.   0. ]
 [ 0.   0.   0.   1.   0. ]]<jupyter_text>Собственные значения матрицы(Matrix eigenvalues) Q8. Compute the eigenvalues and right eigenvectors of x. (Name them eigenvals and eigenvecs, respectively)<jupyter_code>x = np.diag((1, 2, 3)) # форматирование вектора в диагональную матрицу
eigenvals, eigenvecs = np.linalg.eig(x) # вычисляет собственные числа (значения) и собственные векторы квадратной матрицы
print('диагональная матрица х:\n{}\n\nсобственные числа массива х:\neigenvals=\n{}\n\nсобственный вектор массива х:\neigenvecs=\n{}'.format(x,eigenvals, eigenvecs))<jupyter_output>диагональная матрица х:
[[1 0 0]
 [0 2 0]
 [0 0 3]]

собственные числа массива х:
eigenvals=
[1. 2. 3.]

собственный вектор массива х:
eigenvecs=
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]<jupyter_text>Q9. Predict the results of the following code.<jupyter_code>print(np.array_equal(np.dot(x, eigenvecs), eigenvals*eigenvecs))<jupyter_output>True<jupyter_text>Нормы и другие параметры(Norms and other numbers) Q10. Calculate the Frobenius norm and the condition number of x.<jupyter_code>x = np.arange(1, 10).reshape((3, 3))
norm_fro = np.linalg.norm(x, ord='fro') # для матриц возвращается норма Фробениуса, для векторов норма не определена;
condition_fro = np.linalg.cond(x, p='fro') # вычисляет число обусловленности матрицы (Данное число позволяет оценить насколько матрица далека от матрицы полного ранга или от невырожденности для квадратной матрицы) ("p"- позволяет указать необходимую при вычислении норму матрицы)
print(norm_fro,condition_fro)<jupyter_output>16.881943016134134 4.561770736605098e+17<jupyter_text>Q11. Calculate the determinant of x.<jupyter_code>x = np.arange(1, 5).reshape((2, 2))
out1 = np.linalg.det(x) # вычисляет детерминант (определитель) матрицы
out2 = x[0,0]*x[1,1]-x[0,1]*x[1,0] # вычисляем определитель вручную

provision = np.allclose(out1,out2) # условие равенства 2х разных вычислений детерминанта
assert (provision)

print(out1)<jupyter_output>-2.0000000000000004<jupyter_text>Q12. Calculate the rank of x.<jupyter_code>x = np.eye(4) # возвращает массив указанной размерности, у которого все элементы по диагонали равны 1, а все остальные равны 0
rank = np.linalg.matrix_rank(x) # вычисляет ранг матрицы с помощью ее SVD разложения
print(rank)<jupyter_output>4<jupyter_text>Q13. Compute the sign and natural logarithm of the determinant of x.<jupyter_code>x = np.arange(1, 5).reshape((2, 2))
sign, lndet= np.linalg.slogdet(x) # вычисляет знак и натуральный логарифм определителя (детерминанта) матрицы.
det = np.linalg.det(x) # вычисляет определитель (детерминант) матрицы

assert ( sign==np.sign(det)) & (lndet==np.log(np.abs(det)) )

print('знак определителя матрицы х: {}\nнатуральный логарифм определителя матрицы х: {}'.format(sign, det))<jupyter_output>знак определителя матрицы х: -1.0
натуральный логарифм определителя матрицы х: -2.0000000000000004<jupyter_text>Q14. Return the sum along the diagonal of x.<jupyter_code>x = np.eye(4)
sumdiag = np.trace(x) # вычисляет cумму диагональных элементов (след) матрицы
assert x.diagonal().sum()==sumdiag
print(sumdiag)<jupyter_output>4.0<jupyter_text>Решение уравнений и инвертирование матриц(Solving equations and inverting matrices) Q15. Compute the inverse of x.<jupyter_code>x = np.array([[1., 2.], [3., 4.]])
inverse = np.linalg.inv(x) # вычисляет обратную матрицу
assert np.allclose(np.dot(x, inverse), np.eye(2))
print(inverse)<jupyter_output>[[-2.   1. ]
 [ 1.5 -0.5]]<jupyter_text>Дискретные преобразования Фурье(Discrete Fourier Transform)  Комплексные числа(Complex Numbers) Q1. Return the angle of `a` in radian.<jupyter_code>a = 1+1j
output = np.angle(a) # вычисляет угол каждого комплексного числа в массиве
print(output)<jupyter_output>0.7853981633974483<jupyter_text>Q2. Return the real part and imaginary part of `a`.<jupyter_code>a = np.array([1+2j, 3+4j, 5+6j])
real = a.real # извлекает вещественную часть комплексного числа
imag = a.imag # извлекает мнимую часть комплексного числа
print("real part=", real)
print("imaginary part=", imag)<jupyter_output>real part= [1. 3. 5.]
imaginary part= [2. 4. 6.]<jupyter_text>Q3. Replace the real part of a with `9`, the imaginary part with `[5, 7, 9]`.<jupyter_code>a = np.array([1+2j, 3+4j, 5+6j])
a.real = 9 # присваивает поэлементно значение вещественной части комплексного числа
a.imag = [5,7,9] # # присваивает поэлементно значение мнимой части комплексного числа
print(a)<jupyter_output>[9.+5.j 9.+7.j 9.+9.j]<jupyter_text>Q4. Return the complex conjugate of `a`.<jupyter_code>a = 1+2j
output = np.conj(a) # возвращает комплексно-сопряженный элемент, т.е. для каждого входного числа, возвращает число у которого такаяже действительная и мнимая часть, но мнимая часть имеет противоположный знак
print(output)<jupyter_output>(1-2j)<jupyter_text>Дискретное преобразование Фурье(Discrete Fourier Transform) Q5. Compuete the one-dimensional DFT of `a`.<jupyter_code>a = np.exp(2j * np.pi * np.arange(8))
print(a,'\n')
output = np.fft.fft(a) # одномерное дискретное преобразование Фурье
print(output)<jupyter_output>[1.+0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j] 

[ 8.-0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j -0.+0.j -0.+0.j -0.+0.j]<jupyter_text>Q6. Compute the one-dimensional inverse DFT of the `output` in the above question.<jupyter_code>print("a=", a)
inversed = np.fft.ifft(a) #  одномерное обратное преобразование Фурье
print("inversed=", a)<jupyter_output>a= [1.+0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j]
inversed= [1.+0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j 1.-0.j]<jupyter_text>Q7. Compute the one-dimensional discrete Fourier Transform for real input `a`.<jupyter_code>a = [0, 1, 0, 0]
output = np.fft.rfft(a) # Считает одномерное дискретное преобразование Фурье для вещественной части
print(output)
assert output.size==len(a)//2+1 if len(a)%2==0 else (len(a)+1)//2

output2 = np.fft.fft(a)  # Считает одномерное дискретное преобразование Фурье для всего числа
print(output2)<jupyter_output>[ 1.+0.j  0.-1.j -1.+0.j]
[ 1.+0.j  0.-1.j -1.+0.j  0.+1.j]<jupyter_text>Q8. Compute the one-dimensional inverse DFT of the output in the above question.<jupyter_code>inversed = np.fft.ifft(output) # одномерное обратное преобразование Фурье (переменная из примера выше)
print("inversed=", a)<jupyter_output>inversed= [0, 1, 0, 0]<jupyter_text>Q9. Return the DFT sample frequencies of `a`.<jupyter_code>signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=np.float32)
n = signal.size
print('сигнал {}   с длинной окна {}'.format(signal,n))
timestep = 0.001 # Интервал между выборками (обратный к частоте дискретизации). По умолчанию 1
freq = np.fft.fftfreq(n, d=timestep) # возвращает массив, длинной n, состоящий из выборки частот дескретизации
print(freq)<jupyter_output>сигнал [-2.  8.  6.  4.  1.  0.  3.  5.]   с длинной окна 8
[   0.  125.  250.  375. -500. -375. -250. -125.]<jupyter_text>Оконные функции матриц(Window Functions)<jupyter_code>'''
Оконное преобразование Фурье — это разновидность преобразования Фурье,
для визуального улучшения частотного спектра на разрыве границ окна
'''
fig = plt.figure(figsize=(15, 7))

# Hamming window
window = np.hamming(51)
plt.plot(np.bartlett(51), label="оконное треугольное преобрахование (Барлетта)")
plt.plot(np.blackman(51), label="оконное преобразование Блэкмана-Харриса")
plt.plot(np.hamming(51), label="приподнятый косинус (Хэмминга)")
plt.plot(np.hanning(51), label="оконное преобразование Хеннинга")
plt.plot(np.kaiser(51, 14), label="окно Кайзера")
plt.xlabel("выборка")
plt.ylabel("амплитуда")
plt.legend()
plt.grid()

plt.show()<jupyter_output><empty_output><jupyter_text>Логические функции(Logic functions)  Проверка истинности значения(Truth value testing) Q1. Let x be an arbitrary array. Return True if none of the elements of x is zero. Remind that 0 evaluates to False in python.<jupyter_code>x = np.array([1,2,3]) 
print(np.all(x)) # проверка элементов вдоль 1 оси, на значение True (True если ни одного False)
x = np.array([1,0,3])
print(np.all(x)) # проверка элементов вдоль 1 оси, на значение True (True если ни одного False)<jupyter_output>True
False<jupyter_text>Q2. Let x be an arbitrary array. Return True if any of the elements of x is non-zero.<jupyter_code>x = np.array([1,0,0])
print(np.any(x)) # проверка элементов вдоль 1 оси, на значение True (True если хоть 1 True)
x = np.array([0,0,0])
print(np.any(x)) # проверка элементов вдоль 1 оси, на значение True (True если хоть 1 True)<jupyter_output>True
False<jupyter_text>Содержимое массива(Array contents) Q3. Predict the result of the following code.<jupyter_code>x = np.array([1, 0, np.nan, np.inf])
print(np.isfinite(x)) # поэлементная проверка на конечность (не бесконечность или не число).<jupyter_output>[ True  True False False]<jupyter_text>Q4. Predict the result of the following code.<jupyter_code>x = np.array([1, 0, np.nan, np.inf])
print(np.isinf(x)) # поэлементная проверка на полож или отриц. бесконечность (True если бесконечность)<jupyter_output>[False False False  True]<jupyter_text>Q5. Predict the result of the following code.<jupyter_code>x = np.array([1, 0, np.nan, np.inf])
print(np.isnan(x)) # поэлементная проверка на nan-пустоту (0 не считается)<jupyter_output>[False False  True False]<jupyter_text>Проверка вида данных в массивах(Array type testing) Q6. Predict the result of the following code.<jupyter_code>x = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j]) # поэлементная проверка чисел на комплексность (коэф. мнимой части 0 или нет)
print(np.iscomplex(x))<jupyter_output>[ True False False False False  True]<jupyter_text>Q7. Predict the result of the following code.<jupyter_code>x = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j]) # поэлементная проверка чисел на отсутствие комплексности (коэф. мнимой части 0 или нет)
print(np.isreal(x))<jupyter_output>[False  True  True  True  True False]<jupyter_text>Q8. Predict the result of the following code.<jupyter_code>x = 3
y = [3]
z = True
q = 'строка'
a = np.arange(10)
print(np.isscalar(x), type(x)) # поэлементная проверка типа переменной на скалярность
print(np.isscalar(y), type(y)) # поэлементная проверка типа переменной на скалярность
print(np.isscalar(z), type(z)) # поэлементная проверка типа переменной на скалярность
print(np.isscalar(q), type(q)) # поэлементная проверка типа переменной на скалярность
print(np.isscalar(a), type(a)) # поэлементная проверка типа переменной на скалярность<jupyter_output>True <class 'int'>
False <class 'list'>
True <class 'bool'>
True <class 'str'>
False <class 'numpy.ndarray'><jupyter_text>Логические операции(Logical operations) Q9. Predict the result of the following code.<jupyter_code>x = [True, False, True]
y = [True, False, False]
print(np.logical_and(x,y)) # поэлементное сравнение 2х элементов (логич И)
print(np.logical_or(x,y)) # поэлементное сравнение 2х элементов (логич ИЛИ)
print(np.logical_xor(x,y)) # поэлементное сравнение 2х элементов (логич исключ. ИЛИ (сложение по модулю 2) )
print(np.logical_not([True, False, 0, 1])) # логическая инверсия<jupyter_output>[ True False False]
[ True False  True]
[False False  True]
[False  True  True False]<jupyter_text>Сравнения(Comparison) Q10. Predict the result of the following code.<jupyter_code>x=[3]
y=[2.9999999]
print(np.allclose(x,y,0.01)) # проверка на схожесть с опред. точностью
print(np.array_equal(x,y)) # проверка на абсолютную схожесть<jupyter_output>True
False<jupyter_text>Q11. Write numpy comparison functions such that they return the results as you see.<jupyter_code>x = np.array([4, 5])
y = np.array([2, 5])
print(np.greater(x,y)) # поэлементное сравнение массивов (True если эл.Х > эл.У "строго больше")
print(np.greater_equal(x,y)) # поэлементное сравнение массивов (True если эл.Х >= эл.У "больше либо равно")
print(np.less(x,y)) # поэлементное сравнение массивов (True если эл.Х < эл.У "строго меньше")
print(np.less_equal(x,y)) # поэлементное сравнение массивов (True если эл.Х <= эл.У "меньше либо равно")<jupyter_output>[ True False]
[ True  True]
[False False]
[False  True]<jupyter_text>Q12. Predict the result of the following code.<jupyter_code>print(np.equal([1, 2], [1, 2.000001])) # поэлементное сравнение массивов на абсолютное совпадение
print(np.isclose([1, 2], [1, 2.000001])) # поэлементное сравнение массивов (уровень допущения больше единицы)<jupyter_output>[ True False]
[ True  True]<jupyter_text>Математические функции(Mathematical functions)  Тригонометрические функции(Trigonometric functions) Q1. Calculate sine, cosine, and tangent of x, element-wise.<jupyter_code>x = np.array([-1., 0, 1.])
print('sin={}\ncos={}\ntan={}'.format(np.sin(x),np.cos(x),np.tan(x))) # синус, косинус, тангенс кажд. элемента массива<jupyter_output>sin=[-0.8  0.   0.8]
cos=[0.5 1.  0.5]
tan=[-1.6  0.   1.6]<jupyter_text>Q2. Calculate inverse sine, inverse cosine, and inverse tangent of x, element-wise.<jupyter_code>x = np.array([-1., 0, 1.])
# x = np.array([-0.841470984, 0, 0.841470984])
print('arcsin={}\narccos={}\narctan={}'.format(np.arcsin(x),np.arccos(x),np.arctan(x))) # арксинус, арккосинус, арктангенс кажд. элемента массива (обратны синусу, косинусу, тангенсу)<jupyter_output>arcsin=[-1.6  0.   1.6]
arccos=[3.1 1.6 0. ]
arctan=[-0.8  0.   0.8]<jupyter_text>Q3. Convert angles from radians to degrees.<jupyter_code>x = np.array([-np.pi, -np.pi/2, np.pi/2, np.pi]) # = np.array([-3.14159265, -1.57079633,  1.57079633,  3.14159265])
np.rad2deg(x) # перевод радиан в градусы<jupyter_output><empty_output><jupyter_text>Q4. Convert angles from degrees to radians.<jupyter_code>x = np.array([-180.,  -90.,   90.,  180.])
np.deg2rad(x) # перевод градусов в радианы<jupyter_output><empty_output><jupyter_text>Гиперболические функции(Hyperbolic functions) Q5. Calculate hyperbolic sine, hyperbolic cosine, and hyperbolic tangent of x, element-wise.<jupyter_code>x = np.array([-1., 0, 1.])
sinh_x = np.sinh(x) # гиперболический синус
cosh_x = np.cosh(x) # гиперболический косинус
tanh_x = np.tanh(x) # гиперболический тангенс
print('sinh = {}\ncosh = {}\ntanh = {}'.format(sinh_x,cosh_x,tanh_x))<jupyter_output>sinh = [-1.2  0.   1.2]
cosh = [1.5 1.  1.5]
tanh = [-0.8  0.   0.8]<jupyter_text>Округление(Rounding) Q6. Predict the results of these, paying attention to the difference among the family functions.<jupyter_code>x = np.array([2.1, 1.5, 2.5, 2.9, -2.1, -2.5, -2.9])

out1 = np.around(x) # выполняет равномерное (банковское) округление до указанной позиции к ближайшему четному числу. Реальная и мнимая часть комплексных чисел округляется отдельно
out2 = np.floor(x) # выполняет округление к меньшему целому числу
out3 = np.ceil(x) # округляет к большему целому числу
out4 = np.trunc(x) # отбрасывает дробную часть числа
out5 = [round(elem) for elem in x] # округляет до заданного числа цифр и возвращает число с плавающей запятой

print('out1 = ',out1)
print('out2 = ',out2)
print('out3 = ',out3)
print('out4 = ',out4)
print('out5 = ',out5)<jupyter_output>out1 =  [ 2.  2.  2.  3. -2. -2. -3.]
out2 =  [ 2.  1.  2.  2. -3. -3. -3.]
out3 =  [ 3.  2.  3.  3. -2. -2. -2.]
out4 =  [ 2.  1.  2.  2. -2. -2. -2.]
out5 =  [2.0, 2.0, 2.0, 3.0, -2.0, -2.0, -3.0]<jupyter_text>Q7. Implement out5 in the above question using numpy.<jupyter_code>'''
http://numpy-discussion.10968.n7.nabble.com/why-numpy-round-get-a-different-result-from-python-round-function-td19098.html
описана разница между round() и np.around(). Округление идет в обоих случаях в сторону четного числа.
Т.о. такое округление будет одинаково для 2,5 и 1,5
'''
print(np.floor(np.abs(x) + 0.5) * np.sign(x))<jupyter_output>[ 2.  2.  3.  3. -2. -3. -3.]<jupyter_text>Суммы, произведения, сравнения в массивах(Sums, products, differences) Q8. Predict the results of these.<jupyter_code>x = np.array(
    [[1, 2, 3, 4],
     [5, 6, 7, 8]])

outs = [np.sum(x), # сумма всех элементов
        np.sum(x, axis=0), # сумма элементов столбцов (вдоль оси 0)
        np.sum(x, axis=1, keepdims=True),  # сумма элементов строк (вдоль оси 1)
        "",
        np.prod(x), # произведение элементов массива
        np.prod(x, axis=0), # произведение элементов столбцов (вдоль оси 0)
        np.prod(x, axis=1, keepdims=True), #произведение элементов столбцов (вдоль оси 1) (keepdims-задает размерность)
        "",
        np.cumsum(x), # возвращает массив кумулятивных сумм (сумму, к которой послед. прибавляют след элемент)
        np.cumsum(x, axis=0), # возвращает массив куммулятивных сумм вдоль оси 0( 1строка не тронута, к эл. 2-ой строки прибавлены эл. 1-ой строки) 
        np.cumsum(x, axis=1), # возвращает массив куммулятивных сумм вдоль оси 1 (построчную сумму, к которой послед. прибавляют след элемент)
        "",
        np.cumprod(x), # возвращает кумулятивное (накапливаемое) произведение элементов массива (произвед., которое умножается на след. элемент)
        np.cumprod(x, axis=0),  # возвращает кумулятивное (накапливаемое) произведение элементов массива вдоль оси 0 ( 1строка не тронута, эл. 2-ой строки умножены на эл. 1-ой строки)
        np.cumprod(x, axis=1), # возвращает кумулятивное (накапливаемое) произведение элементов массива вдоль оси 1 (построчно)
        "",
        np.min(x), # наименьший элемент массива
        np.min(x, axis=0), # наименьший элемент массива вдоль оси 0 (возвращает строку)
        np.min(x, axis=1, keepdims=True), # наименьший элемент массива вдоль оси 1 (возвращает столбец)
        "",
        np.max(x), # наибольший элемент массива
        np.max(x, axis=0), # наибольший элемент массива вдоль оси 0 (возвращает строку)
        np.max(x, axis=1, keepdims=True), # наибольший элемент массива вдоль оси 1 (возвращает столбец)
        "",
        np.mean(x), # вычисляет среднее арифметическое значений элементов массива
        np.mean(x, axis=0), # вычисляет среднее арифметическое значений элементов массива вдоль оси 0 (ср. арифм. столбцов)
        np.mean(x, axis=1, keepdims=True)] # вычисляет среднее арифметическое значений элементов массива вдоль оси 0 (ср. арифм. строк)
           
for out in outs:
    if out == "":
#         pass
        print()
    else:
        pass
        print("->", out)<jupyter_output>-> 36
-> [ 6  8 10 12]
-> [[10]
 [26]]

-> 40320
-> [ 5 12 21 32]
-> [[  24]
 [1680]]

-> [ 1  3  6 10 15 21 28 36]
-> [[ 1  2  3  4]
 [ 6  8 10 12]]
-> [[ 1  3  6 10]
 [ 5 11 18 26]]

-> [    1     2     6    24   120   720  5040 40320]
-> [[ 1  2  3  4]
 [ 5 12 21 32]]
-> [[   1    2    6   24]
 [   5   30  210 1680]]

-> 1
-> [1 2 3 4]
-> [[1]
 [5]]

-> 8
-> [5 6 7 8]
-> [[4]
 [8]]

-> 4.5
-> [3. 4. 5. 6.]
-> [[2.5]
 [6.5]]<jupyter_text>Q9. Calculate the difference between neighboring elements, element-wise.<jupyter_code>x = np.array([1, 2, 4, 7, 0])
np.diff(x) # возвращает разницу между соседними элементами массива<jupyter_output><empty_output><jupyter_text>Q10. Calculate the difference between neighboring elements, element-wise, andprepend [0, 0] and append[100] to it.<jupyter_code>x = np.array([1, 2, 4, 7, 0])
np.ediff1d(x, to_begin=[0, 0], to_end=[100]) # возвращает разность между последовательными элементами массива. Если входной массив является многомерным, то он сжимается до одной оси. Так же добавляет элементы в начале и в конце выводимого массива<jupyter_output><empty_output><jupyter_text>Q11. Return the cross product of x and y.<jupyter_code>x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
np.cross(x, y) # вычисляет векторное произведение двух векторов в "кол-во эл. векторов-мерном" пространстве<jupyter_output><empty_output><jupyter_text>Экспонента и логарифмы(Exponents and logarithms) Q12. Compute $e^x$, element-wise.<jupyter_code>x = np.array([1., 2., 3.], np.float32)
np.exp(x) # вычисляет экспоненту всех элементов массива<jupyter_output><empty_output><jupyter_text>Q13. Calculate exp(x) - 1 for all elements in x.<jupyter_code>x = np.array([1., 2., 3.], np.float32)
y = np.expm1(x) # вычисляет exp(x)-1 всех элементов массива, обеспечивая большую точность для малых x
z = np.exp(x)-1
print(y,z)<jupyter_output>[ 1.7  6.4 19.1] [ 1.7  6.4 19.1]<jupyter_text>Q14. Calculate $2^p$ for all p in x.<jupyter_code>x = np.array([1., 2., 3.], np.float32)
y = np.exp2(x) # вычисляет степени двойки т.е. 2**x для всех x входного массива
z = 2**x
print(y,z)<jupyter_output>[2. 4. 8.] [2. 4. 8.]<jupyter_text>Q15. Compute natural, base 10, and base 2 logarithms of x element-wise.<jupyter_code>x = np.array([1, np.e, np.e**2])
lnx = np.log(x) # вычисляет натуральный логарифм элементов массива
lgx = np.log10(x) # вычисляет десятичный логарифм элементов массива
log2x = np.log2(x) # вычисляет двоичный логарифм элементов массива
print(x,'\n',lnx,'\t',lgx,'\t',log2x)<jupyter_output>[1.  2.7 7.4] 
 [0. 1. 2.] 	 [0.  0.4 0.9] 	 [0.  1.4 2.9]<jupyter_text>Q16. Compute the natural logarithm of one plus each element in x in floating-point accuracy.<jupyter_code>x = np.array([1e-99, 1e-100])
np.log1p(x) # вычисляет log(x+1) для всех x входного массива<jupyter_output><empty_output><jupyter_text>Процедуры с плавающей точкой(Floating point routines) Q17. Return element-wise True where signbit is set.<jupyter_code>x = np.array([-3, -2, -1, 0, 1, 2, 3])
np.signbit(x) # True если число отрицательное<jupyter_output><empty_output><jupyter_text>Q18. Change the sign of x to that of y, element-wise.<jupyter_code>x = np.array([-1, 0, 1])
y = -59
np.copysign(x,y) # изменяет знак элементов из массива x на знак элементов из массива y. Если y число, то у всех эл. его знак<jupyter_output><empty_output><jupyter_text>Арифметические операции(Arithmetic operations) Q19. Add x and y element-wise.<jupyter_code>x = np.array([1, 2, 3])
y = np.array([-1, -2, -3])
out1 = x + y # выполняет поэлементную сумму массивов
out2 = np.add(x,y) # выполняет поэлементную сумму массивов
condition = np.array_equal(out2, out1) # проверяем равенство массивов
print(out2, condition)<jupyter_output>[0 0 0] True<jupyter_text>Q20. Subtract y from x element-wise.<jupyter_code>x = np.array([3, 4, 5])
y = np.array(3)
out1 = x - y # выполняет поэлементную разность массивов
out2 = np.subtract(x,y) # выполняет поэлементную разность массивов
condition = np.array_equal(out2, out1) # проверяем равенство массивов
print(out1, condition)<jupyter_output>[0 1 2] True<jupyter_text>Q21. Multiply x by y element-wise.<jupyter_code>x = np.array([3, 4, 5])
y = np.array([1, 0, -1])
out1 = np.multiply(x,y) # выполняет поэлементную перемножение массивов
out2 = x*y # выполняет поэлементную перемножение массивов
condition = np.array_equal(out2, out1) # проверяем равенство массивов
print(out1, condition)<jupyter_output>[ 3  0 -5] True<jupyter_text>Q22. Divide x by y element-wise in two different ways.<jupyter_code>x = np.array([3., 4., 11.])
y = np.array([1., 2., 3.])
out1 = np.true_divide(x,y) # вычисляет поэлементное ИСТИННОЕ деление значений указанных массивов
out2 = x/y # в Python3 out1 эквивалентен out2

out3 = np.floor_divide(x,y) # выполняет поэлементное ЦЕЛОЧИСЛЕННОЕ деление значений массива
print(out1,'\t',out3)<jupyter_output>[3.  2.  3.7] 	 [3. 2. 3.]<jupyter_text>Q23. Compute numerical negative value of x, element-wise.<jupyter_code>x = np.array([1, -1])
out1 = np.negative(x) # выполняет смену знака всех элементов массива
out2 = -x # выполняет смену знака всех элементов массива
condition = np.array_equal(out2, out1) # проверяем равенство массивов
print(out1, condition)<jupyter_output>[-1  1] True<jupyter_text>Q24. Compute the reciprocal of x, element-wise.<jupyter_code>x = np.array([1., 2., .2])
out1 = np.reciprocal(x) # поэлементно вычисляет обратное значение массива
out2 = 1/x
assert np.array_equal(out1, out2) # проверяем равенство массивов
print(out1)<jupyter_output>[1.  0.5 5. ]<jupyter_text>Q25. Compute $x^y$, element-wise.<jupyter_code>x = np.array([[1, 2], [3, 4]])
y = np.array([[1, 2], [1, 2]])
np.power(x, y) # выполняет возведение элементов из массива x в степень элементов из массива y.<jupyter_output><empty_output><jupyter_text>Q26. Compute the remainder of x / y element-wise in two different ways.<jupyter_code>x = np.array([-3, -2, -1, 1, 2, 3])
y = 2
out1 = np.mod(x,y) # поэлементно вычисляет остаток от деления значений массива x на значения массива y, не сохраняя знак x
out2 = x%y # поэлементно вычисляет остаток от деления значений массива x на значения массива y, не сохраняя знак x
assert np.array_equal(out1, out2) # проверяем равенство массивов
print(out1)

out3 = np.fmod(x,y) # поэлементно вычисляет остаток от деления значений массива x на значения массива y, сохраняя знак x
print(out3)<jupyter_output>[1 0 1 1 0 1]
[-1  0 -1  1  0  1]<jupyter_text>Разнообразные мат. операции(Miscellaneous) Q27. If an element of x is smaller than 3, replace it with 3.And if an element of x is bigger than 7, replace it with 7.<jupyter_code>x = np.arange(10)
y = np.clip(x, 3, 7) # ограниченичивает элементы массива указанным интервалом допустимых значений
z = np.copy(x) # создаем дубликат массива
z[z<3]=3 # все элементы массива, которые меньше чем 3, приравниваем к 3
z[z>7]=7 # все элементы массива, которые больше чем 7, приравниваем к 7
print(y,z)<jupyter_output>[3 3 3 3 4 5 6 7 7 7] [3 3 3 3 4 5 6 7 7 7]<jupyter_text>Q28. Compute the square of x, element-wise.<jupyter_code>x = np.array([1, 2, -1])
out1 = np.square(x) # вычисляет квадрат элементов массива, т.е. каждый элемент массива умножается сам на себя
out2 = x*x # вычисляет квадрат элементов массива, т.е. каждый элемент массива умножается сам на себя
assert np.array_equal(out1, out2) # проверяем равенство массивов
print(out1)<jupyter_output>[1 4 1]<jupyter_text>Q29. Compute square root of x element-wise.<jupyter_code>x = np.array([1., 4., 9.])
out1 = np.sqrt(x) # вычисляет квадратный корень элементов массива
out2 = x**0.5 # вычисляет квадратный корень элементов массива
assert np.array_equal(out1, out2) # проверяем равенство массивов
print(out1)<jupyter_output>[1. 2. 3.]<jupyter_text>Q30. Compute the absolute value of x.<jupyter_code>x = np.array([[1, -1], [3, -3]])
np.abs(x) # возвращает абсолютное значение (модуль) элементов массива<jupyter_output><empty_output><jupyter_text>Q31. Compute an element-wise indication of the sign of x, element-wise.<jupyter_code>x = np.array([1, 3, 0, -1, -3])
np.sign(x) # является указателем на знак числа.<jupyter_output><empty_output><jupyter_text>Случайная выборка(Random Sampling)  Простая случайная выборка(Simple random data) Q1. Create an array of shape (3, 2) and populate it with random samples from a uniform distribution over [0, 1).<jupyter_code>np.random.rand(3,2) # Массив случайных значений, принадлежащих интервалу [0,1) заданной формы<jupyter_output><empty_output><jupyter_text>Q2. Create an array of shape (1000, 1000) and populate it with random samples from a standard normal distribution. And verify that the mean and standard deviation is close enough to 0 and 1 repectively.<jupyter_code>out1 = np.random.rand(1000,1000) # Массив случайных значений заданной формы
out2 = np.random.standard_normal((1000,1000)) # Массив случайных значений, распределенный по теор. Гаусса, заданной формы
out3 = np.random.normal(loc=0, scale = 1, size=(1000,1000)) # Массив случайных значений, распределенный по теор. Гаусса, заданной формы

assert np.allclose(np.mean(out2), np.mean(out3), atol=0.1) # проверка похожести массивов с заданной точностью
assert np.allclose(np.std(out2),np.std(out3), atol=0.1) # проверка похожести массивов с заданной точностью

print(np.mean(out3)) # вычисляет среднее арифметическое значений элементов массива
print(np.std(out3)) # вычисляет среднеквадратичное (стандартное) отклонение значений элементов массива<jupyter_output>0.0002448498967632188
0.9997749347163097<jupyter_text>Q3. Create an array of shape (3, 2) and populate it with random integers ranging from 0 to 3 (inclusive) from a discrete uniform distribution.<jupyter_code>x = np.random.randint(low=0,high=4,size=(3,2)) # Массив случайных целых чисел из интервала
'''
low - Нижняя граница интервала [low,high) (по умолч = 0).
high - Верхняя граница интервала [low,high) (по умолч = None).
Если hihg не указан, то интервал значений изменяется на [0, low).
size - размерность массива.
можно также записать, без указания параметров np.random.randint(0,4,(3,2))
'''
print(x)<jupyter_output>[[2 2]
 [1 1]
 [0 0]]<jupyter_text>Q4. Extract 1 elements from x randomly such that each of them would be associated with probabilities .3, .5, .2. Then print the result 10 times.<jupyter_code>'''
numpy.random.choice(a, size=None, replace=True, p=None)

a - целое положительное число, одномерный массив или одномерная последовательность.
Если указан массив или последовательность, то выборка генерируется из его элементов.
Если указано число, то выборка генерируется из массива аналогичного np.arange(a).

size - целое положительное число или кортеж целых положительных чисел, необязательный параметр
Если данный параметр не указан, то будет возвращено одно целое случайное число.
Если указано одно число d, то будет возвращен одномерный массив с количеством элементов равным d.
Если указано несколько чисел, то количество этих чисел будет определять количество осей массива,
а их значения - количество элементов вдоль каждой из них.

replace - True или False, необязательный параметр
Данный параметр определяет уникальность элементов в выборке.
По умолчанию replace=True, т.е. элементы в выборке могут повторяться.

p - одномерный массив или одномерная последовательность, необязательный параметр
Каждый элемент массива p определяет вероятность соответствующего элемнта из a оказаться в выборке.
Входной массив a и p должны быть одинаковой длинны, а сумма элементов массива p должна быть равна 1.
По умолчанию p = None, что соответствует равномерному распределению вероятности.

print( np.random.choice(x, p=[0.3,0.5,0.2]) )
'''
x = ['3 out of 10', '5 out of 10', '2 out of 10']
for _ in range(10):
    print( np.random.choice(x, p=[0.3, 0.5, 0.2]) ) # Случайная выборка из значений заданного одномерного массива<jupyter_output>5 out of 10
3 out of 10
5 out of 10
3 out of 10
3 out of 10
5 out of 10
2 out of 10
3 out of 10
3 out of 10
5 out of 10<jupyter_text>Q5. Extract 3 different integers from 0 to 9 randomly with the same probabilities.<jupyter_code>np.random.choice(10,3, replace = False) # Случайная выборка из значений заданного одномерного массива. replace запрещает повторения эл. в массиве<jupyter_output><empty_output><jupyter_text>Перестановки(Permutations) Q6. Shuffle numbers between 0 and 9 (inclusive).<jupyter_code>x=np.arange(10)
print(x)
np.random.shuffle(x) # возвращает случайную перестановку элементов указанного массива
print(x)
# Or
np.random.permutation(10) # возвращает случайную перестановку элементов массива или случайную последовательность заданной длинны из его элементов<jupyter_output><empty_output><jupyter_text>Генератор случайных чисел(Random generator) Q7. Assign number 10 to the seed of the random generator so that you can get the same value next time.<jupyter_code>np.random.seed(10) # задает начальные условия для генератора случайных чисел. Число в интервале [0, 2**32] - определяет внутреннее состояние генератора
out1 = np.random.rand()
np.random.seed(10) # задает начальные условия для генератора случайных чисел
out2 = np.random.rand()
assert out1 == out2
print(out2)<jupyter_output>0.771320643266746<jupyter_text>Процедуры над множестами(Set routines)  Создание собственных множеств(Making proper sets) Q1. Get unique elements and reconstruction indices from x. And reconstruct x.<jupyter_code>x = np.array([1, 2, 6, 4, 2, 3, 2])
uniq_el, index = np.unique(x, return_inverse=True) # находит уникальные элементы массива и возвращает их в отсортированном массиве.
'''
numpy.unique(a, return_index=False, return_inverse=False, return_counts=False, axis=None)
В зависимости от установленных параметров, данная функция может возвращать:
- индексы входного массива, которые соответствуют его уникальным элементам;
- индексы уникального массива, которые позволяют восстановить входной массив;
- количество вхождений каждого уникального элемента во входном массиве.
'''

print(uniq_el) # все уникальные элементы массива
print(index) # индексы элементов в новом множестве, под которыми стоят элементы в массиве
print(uniq_el[index]) # восстановленный оригинальный массив<jupyter_output>[1 2 3 4 6]
[0 1 4 3 1 2 1]
[1 2 6 4 2 3 2]<jupyter_text>Булевы операции(Boolean operations) Q2. Create a boolean array of the same shape as x. If each element of x is present in y, the result will be True, otherwise False.<jupyter_code>x = np.array([0, 1, 2, 5, 0])
y = np.array([0, 1])
np.in1d(x,y) # поэлементная сверка эл. массива x на присутствие в массиве y<jupyter_output><empty_output><jupyter_text>Q3. Find the unique intersection of x and y.<jupyter_code>x = np.array([0, 1, 2, 3, 0])
y = np.array([0, 2, 8])
z = np.intersect1d(x,y) # выводит массив УНИКАЛЬНЫХ элементов x, которые присутствуют в масиве y
print(z)<jupyter_output>[0 2]<jupyter_text>Q4. Find the unique elements of x that are not present in y.<jupyter_code>x = np.array([0, 1, 2, 3, 2])
y = np.array([0, 1, 4])
np.setdiff1d(x,y) # выводит массив УНИКАЛЬНЫХ элементов x, которые НЕ присутствуют в масиве y<jupyter_output><empty_output><jupyter_text>Q5. Find the xor elements of x and y.<jupyter_code>x = np.array([0, 1, 2, 3, 5, 5])
y = np.array([0, 1, 2, 4, 4])
out1 = np.setxor1d(x,y) # выводит массив отсортированных УНИКАЛЬНЫХ элементов x и y, которые НЕ присутствуют в обоих массивах одновременно
out2 = np.concatenate((np.setdiff1d(x, y), np.setdiff1d(y, x)))

assert np.array_equal(out1, np.sort(out2)) # условие равенства массивов
print(out1)<jupyter_output>[3 4 5]<jupyter_text>Q6. Find the union of x and y.<jupyter_code>x = np.array([0, 1, 2, 4, 0])
y = np.array([0, 1, 3, 3])
np.union1d(x,y) # выводит массив сортированных УНИКАЛЬНЫХ значений указанных массивов, которые МОГУТ присутствовать в обоих массивах<jupyter_output><empty_output><jupyter_text>Сортировка, поиск и пересчет(Sorting, searching, and counting)  Сортировка(Sorting) Q1. Sort x along the second axis.<jupyter_code>x = np.array([[1,4],[3,1]])
np.sort(x,axis=1) # сортировка массива по указанной оси<jupyter_output><empty_output><jupyter_text>Q2. Sort pairs of surnames and first names and return their indices. (first by surname, then by name).<jupyter_code>surnames =    ('Hertz',    'Aalilei', 'Hertz')
first_names = ('Heinrich', 'Zalileo', 'Gustav')
np.lexsort([first_names,surnames]) # выводит связанные индексы обратноотсортированных по x ключей массивов

x = ['A','B','C']
y = ['F','E','D']
np.lexsort([y,x]) # выводит связанные индексы обратноотсортированных по x ключей массивов<jupyter_output><empty_output><jupyter_text>Q3. Get the indices that would sort x along the second axis.<jupyter_code>x = np.array([[1,4],[3,1]])
np.argsort(x,axis=1) # возвращает индексы, сортирующие элементы исходного массива<jupyter_output><empty_output><jupyter_text>Q4. Create an array such that its `fifth` element would be the same as the element of sorted x, and it divide other elements by their value.<jupyter_code>x = np.random.permutation(10) # массив случайной сортировки значений до 10
y = np.partition(x,5)
'''
numpy.partition(a, kth, axis=-1, kind='introselect', order=None)
Функция partition() возвращает копию исходного массива элементы которого разделены по указанному значению.

Параметр kth=4 указывает на индекс элемента в отсортированной копии исходного массива,
но в возвращаемом массиве только этот элемент и сохраняет свое положение,
все элементы с меньшим значением переносятся влево, а с большим или равным значением переносятся вправо,
причем порядок элементов слева и справа никак не определен.
'''
print(x,'\t',x[5])
print(y)<jupyter_output>[2 6 8 5 7 9 3 1 0 4] 	 9
[3 2 0 1 4 5 6 7 8 9]<jupyter_text>Q5. Create the indices of an array such that its `third` element would be the same as the element of sorted x, and it divide other elements by their value.<jupyter_code>x = np.random.permutation(10) # массив случайной сортировки значений до 10
partitioned = np.partition(x,3) # возвращает копию исходного массива элементы которого разделены по указанному значению.
index = np.argpartition(x,3) # возвращает массив индексов элементов исходного массива в их разбиении по указанному значению
'''
numpy.argpartition(a, kth, axis=-1, kind='introselect', order=None)
Работа данной функции абсолютно аналогична numpy.partition(),
но вместо копии разделенного исходного массива она возвращает массив индексов его элементов в этом разбиении.
'''
print(x,'\t', x[3])
print(partitioned)
print(index)<jupyter_output>[3 7 4 5 6 2 0 9 8 1] 	 5
[2 1 0 3 7 5 4 9 8 6]
[5 9 6 0 1 3 2 7 8 4]<jupyter_text>Поиск(Searching) Q6. Get the maximum and minimum values and their indices of x along the `second` axis.<jupyter_code>x = np.random.permutation(10).reshape(2,5) # массив случайной сортировки значений до 10 заданной формы
print(x)
print('ЗНАЧЕНИЯ элементов:')
print(np.min(x,axis=1)) # выводит ЗНАЧЕНИЯ наименьших элементов каждой строки (если axis=1) в одном массиве
print(np.max(x,axis=1)) # выводит ЗНАЧЕНИЯ наибольших каждой строки (если axis=1) в одном массиве
print('ИНДЕКСЫ элементов:')
print(np.argmin(x,axis=1)) # выводит ИНДЕКСЫ наименьших элементов каждой строки (если axis=1) в одном массиве
print(np.argmax(x,axis=1)) # выводит ИНДЕКСЫ наибольших каждой строки (если axis=1) в одном массиве<jupyter_output>[[5 1 8 2 6]
 [9 3 7 4 0]]
ЗНАЧЕНИЯ элементов:
[1 0]
[8 9]
ИНДЕКСЫ элементов:
[1 4]
[2 0]<jupyter_text>Q7. Get the maximum and minimum values and their indices of x along the second axis, ignoring NaNs.<jupyter_code>x = np.array([[np.nan, 4, 3], [3, -2, np.nan]])
print(x)
'''
ниже ИГНОРИРУЮТСЯ nan-значения массива x
'''
print('ЗНАЧЕНИЯ элементов:')
print(np.nanmin(x,axis=1)) # выводит ЗНАЧЕНИЯ наименьших элементов каждой строки (если axis=1) в одном массиве, игнорируя nan-значения
print(np.nanmax(x,axis=1)) # выводит ЗНАЧЕНИЯ наибольших каждой строки (если axis=1) в одном массиве, игнорируя nan-значения
print('ИНДЕКСЫ элементов:')
print(np.nanargmin(x,axis=1)) # выводит ИНДЕКСЫ наименьших элементов каждой строки (если axis=1) в одном массиве, игнорируя nan-значения
print(np.nanargmax(x,axis=1)) # выводит ИНДЕКСЫ наибольших каждой строки (если axis=1) в одном массиве, игнорируя nan-значения<jupyter_output>[[nan  4.  3.]
 [ 3. -2. nan]]
ЗНАЧЕНИЯ элементов:
[ 3. -2.]
[4. 3.]
ИНДЕКСЫ элементов:
[2 1]
[1 0]<jupyter_text>Q8. Get the `values` and `indices` of the elements that are `bigger` than `2` in x.<jupyter_code>x = np.array([[1, 2, 3], [1, 3, 5]])
'''
numpy.nonzero(a)
грубо говоря выводит кортеж разнесенных координат найденых чисел: так например,
у первой тройки координаты (0,2) (т.е. располож в 1-ой строке и 3-ем столбце),
у второй тройки координаты (1,1) (т.е. располож во 2-ой строке и 2-ом столбце),
у пятерки координаты (1,2) (т.е. располож во 2-ой строке и 3-ем столбце).
Эти значения координат разнесены по разным массивам (разделение по осям)
'''
print(x)
print('Значения, которые больше 2-х: {}'.format(x[x>2]))
print( 'Их индексы: {}'.format(np.nonzero(x>2)) )<jupyter_output>[[1 2 3]
 [1 3 5]]
Значения, которые больше 2-х: [3 3 5]
Их индексы: (array([0, 1, 1], dtype=int64), array([2, 1, 2], dtype=int64))<jupyter_text>Q9. Get the `indices` of the elements that are `bigger` than `2` in the `flattend x`.<jupyter_code>x = np.array([[1, 2, 3], [1, 3, 5]])
np.flatnonzero(x>2) # возвращает индексы ненулевых элементов в сжатом до одной оси представлении указанного массива<jupyter_output><empty_output><jupyter_text>Q10. Check the `elements` of x and return `0` if it is `less than 0`, otherwise `the element itself`.<jupyter_code>x = np.arange(-5, 4).reshape(3, 3)
np.where(x<0, 0, x) # сравнивает эл-ты с 0 и выдает 0 если True, иначе само число<jupyter_output><empty_output><jupyter_text>Q11. Get the `indices` where elements of `y` should `be inserted` to x to `maintain order`.<jupyter_code>x = [1, 3, 5, 7, 9]
y = [0, 4, 2, 6]
np.searchsorted(x, y) # возвращает индексы в которые должны быть вставлены элементы y, что бы порядок сортировки был сохранен<jupyter_output><empty_output><jupyter_text>Пересчет(Counting) Q12. Get the number of nonzero elements in x.<jupyter_code>x = [[0,1,7,0,0],[3,0,0,2,19]]
np.count_nonzero(x) # возвращает количество ненулевых элементов массива вдоль указанной оси (если ось не указана, идет расчет по сжатому до 1 оси массиву)<jupyter_output><empty_output><jupyter_text>Статистики(Statistics)  Порядковые статистикиOrder statistics Q1. Return the minimum value of x along the second axis.<jupyter_code>x = np.arange(4).reshape((2, 2))
print("x=\n", x)
x = np.arange(4).reshape((2, 2))
print("x=\n", x)<jupyter_output>x=
 [[0 1]
 [2 3]]<jupyter_text>Q2. Return the maximum value of x along the second axis. Reduce the second axis to the dimension with size one.<jupyter_code>x = np.arange(4).reshape((2, 2))
print("x=\n", x)<jupyter_output>x=
 [[0 1]
 [2 3]]<jupyter_text>Q3. Calcuate the difference between the maximum and the minimum of x along the second axis.<jupyter_code>x = np.arange(10).reshape((2, 5))
print("x=\n", x)<jupyter_output>x=
 [[0 1 2 3 4]
 [5 6 7 8 9]]<jupyter_text>Q4. Compute the 75th percentile of x along the second axis.<jupyter_code>x = np.arange(1, 11).reshape((2, 5))
print("x=\n", x)<jupyter_output>x=
 [[ 1  2  3  4  5]
 [ 6  7  8  9 10]]<jupyter_text>Средние и отклонения(Averages and variances) Q5. Compute the median of flattened x.<jupyter_code>x = np.arange(1, 10).reshape((3, 3))
print("x=\n", x)<jupyter_output>x=
 [[1 2 3]
 [4 5 6]
 [7 8 9]]<jupyter_text>Q6. Compute the weighted average of x.<jupyter_code>x = np.arange(5)
weights = np.arange(1, 6)
weights<jupyter_output><empty_output><jupyter_text>Q7. Compute the mean, standard deviation, and variance of x along the second axis.<jupyter_code>x = np.arange(5)
print("x=\n",x)<jupyter_output>x=
 [0 1 2 3 4]<jupyter_text>Корреляция(Correlating) Q8. Compute the covariance matrix of x and y.<jupyter_code>x = np.array([0, 1, 2])
y = np.array([2, 1, 0])<jupyter_output><empty_output><jupyter_text>Q9. In the above covariance matrix, what does the -1 mean? Q10. Compute Pearson product-moment correlation coefficients of x and y.<jupyter_code>x = np.array([0, 1, 3])
y = np.array([2, 4, 5])<jupyter_output><empty_output><jupyter_text>Q11. Compute cross-correlation of x and y.<jupyter_code>x = np.array([0, 1, 3])
y = np.array([2, 4, 5])<jupyter_output><empty_output><jupyter_text>Гистограммы(Histograms) Q12. Compute the histogram of x against the bins.<jupyter_code>x = np.array([0.5, 0.7, 1.0, 1.2, 1.3, 2.1])
bins = np.array([0, 1, 2, 3])
print("ans=\n", ...)

plt.hist(x, bins=bins)
plt.show()<jupyter_output>ans=
 Ellipsis<jupyter_text>Q13. Compute the 2d histogram of x and y.<jupyter_code>xedges = [0, 1, 2, 3]
yedges = [0, 1, 2, 3, 4]
x = np.array([0, 0.1, 0.2, 1., 1.1, 2., 2.1])
y = np.array([0, 0.1, 0.2, 1., 1.1, 2., 3.3])
...

plt.scatter(x, y)
plt.grid()<jupyter_output><empty_output><jupyter_text>Q14. Count number of occurrences of 0 through 7 in x.<jupyter_code>x = np.array([0, 1, 1, 3, 2, 1, 7])<jupyter_output><empty_output><jupyter_text>Q15. Return the indices of the bins to which each value in x belongs.<jupyter_code>x = np.array([0.2, 6.4, 3.0, 1.6])
bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13565296566077004, 'fraction_numerical': 0.048738293444328826, 'mean_word_length': 4.8773029584894125, 'pattern_counts': {'":': 13, '<': 654, '<?xml version=': 0, '>': 679, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 7, 'word_list_counts': {'cursed_substrings.json': 38, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '183', 'dir': 'jupyter-structured-clean-dedup', 'id': '204611', 'license': 'MIT', 'n_tokens_mistral': 34754, 'n_tokens_neox': 35040, 'n_words': 8639, 'path': 'NumPy Cheatsheet.ipynb', 'repo_name': 'IamSVP94/numpy_exercises', 'size': '76880'}