Numpy.linalg.inv

Копии и представления

При работе с массивами, их данные иногда необходимо копировать в другой массив, а иногда нет. Это часто является источником путаницы. Возможно 3 случая:

Вообще никаких копий

Простое присваивание не создает ни копии массива, ни копии его данных:

>>> a = np.arange(12)
>>> b = a  # Нового объекта создано не было
>>> b is a  # a и b это два имени для одного и того же объекта ndarray
True
>>> b.shape = (3,4)  # изменит форму a
>>> a.shape
(3, 4)

Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий.

Представление или поверхностная копия

Разные объекты массивов могут использовать одни и те же данные. Метод view() создает новый объект массива, являющийся представлением тех же данных.

>>> c = a.view()
>>> c is a
False
>>> c.base is a  # c это представление данных, принадлежащих a
True
>>> c.flags.owndata
False
>>>
>>> c.shape = (2,6)  # форма а не поменяется
>>> a.shape
(3, 4)
>>> c,4 = 1234  # данные а изменятся
>>> a
array(,
       ,
       ])

Срез массива это представление:

>>> s = a = 10
>>> a
array(,
       ,
       ])

Глубокая копия

Метод copy() создаст настоящую копию массива и его данных:

>>> d = a.copy()  # создается новый объект массива с новыми данными
>>> d is a
False
>>> d.base is a  # d не имеет ничего общего с а
False
>>> d,  = 9999
>>> a
array(,
       ,
       ])

3.10. Прочие математические функции

Дискретная линейная свертка.

Ограничение значений массивов указанным интервалом допустимых значений.

Квадратный корень элементов массива.

Кубический корень элементов массива.

Квадрат элементов массива.

Абсолютное значение (модуль) элементов массива.

Возвращает абсолютное значение (модуль) элементов массива в виде чисел с плавающей точкой.

Элементарный указатель на знак числа.

Ступенчатая функция Хевисайда.

Наибольшие значения после поэлементного сравнения значений массивов.

Наименьшие значения после поэлементного сравнения значений массивов.

Наибольшие значения после поэлементного сравнения значений массивов в виде чисел с плавающей точкой.

Наименьшие значения после поэлементного сравнения значений массивов в виде чисел с плавающей точкой.

Заменяет nan на 0, бесконечность и минус-бесконечность заменяются на наибольшее и наименьшее доступное число с плавающей точкой соответственно.

Переводит комплексные числа в вещественные если мнимая часть комплексного числа меньше машинной эпсилон.

Одномерная линейная интерполяция.

Функции обработки сигналов

Обработка сигналов — это область анализа, модификации и синтеза сигналов: звуков, изображений и т. д. SciPy предоставляет некоторые функции, с помощью которых можно проектировать, фильтровать и интерполировать одномерные и двумерные данные.

Фильтрация:

Фильтруя сигнал, можно удалить нежелаемые составляющие. Для выполнения упорядоченной фильтрации используется функция . Она выполняет операцию на массиве. Синтаксис следующий:

— N-мерный массив с входящими данными

— массив масок с тем же количеством размерностей, что и у массива

— неотрицательное число, которое выбирает элементы из отсортированного списка (0, 1…)

Пример:

Вывод:

Сигналы

Подпакет также состоит из функций, с помощью которых можно генерировать сигналы. Одна из таких — . Она является генератором частотно-модулированного сигнала, а ее синтаксис следующий:

Пример:

Вывод:

Создание массивов

В NumPy существует много способов создать массив. Один из наиболее простых — создать массив из обычных списков или кортежей Python, используя функцию numpy.array() (запомните: array — функция, создающая объект типа ndarray):

>>> import numpy as np
>>> a = np.array()
>>> a
array()
>>> type(a)
<class 'numpy.ndarray'>

Функция array() трансформирует вложенные последовательности в многомерные массивы. Тип элементов массива зависит от типа элементов исходной последовательности (но можно и переопределить его в момент создания).

>>> b = np.array(, 4, 5, 6]])
>>> b
array(,
       ])

Можно также переопределить тип в момент создания:

>>> b = np.array(, 4, 5, 6]], dtype=np.complex)
>>> b
array(,
       ])

Функция array() не единственная функция для создания массивов. Обычно элементы массива вначале неизвестны, а массив, в котором они будут храниться, уже нужен. Поэтому имеется несколько функций для того, чтобы создавать массивы с каким-то исходным содержимым (по умолчанию тип создаваемого массива — float64).

Функция zeros() создает массив из нулей, а функция ones() — массив из единиц. Обе функции принимают кортеж с размерами, и аргумент dtype:

>>> np.zeros((3, 5))
array(,
       ,
       ])
>>> np.ones((2, 2, 2))
array(,
        ],

       ,
        ]])

Функция eye() создаёт единичную матрицу (двумерный массив)

>>> np.eye(5)
array(,
       ,
       ,
       ,
       ])

Функция empty() создает массив без его заполнения. Исходное содержимое случайно и зависит от состояния памяти на момент создания массива (то есть от того мусора, что в ней хранится):

>>> np.empty((3, 3))
array(,
       ,
       ])
>>> np.empty((3, 3))
array(,
       ,
       ])

Для создания последовательностей чисел, в NumPy имеется функция arange(), аналогичная встроенной в Python range(), только вместо списков она возвращает массивы, и принимает не только целые значения:

>>> np.arange(10, 30, 5)
array()
>>> np.arange(, 1, 0.1)
array()

Вообще, при использовании arange() с аргументами типа float, сложно быть уверенным в том, сколько элементов будет получено (из-за ограничения точности чисел с плавающей запятой). Поэтому, в таких случаях обычно лучше использовать функцию linspace(), которая вместо шага в качестве одного из аргументов принимает число, равное количеству нужных элементов:

>>> np.linspace(, 2, 9)  # 9 чисел от 0 до 2 включительно
array()

fromfunction(): применяет функцию ко всем комбинациям индексов

Печать массивов

Если массив слишком большой, чтобы его печатать, NumPy автоматически скрывает центральную часть массива и выводит только его уголки.

>>> print(np.arange(, 3000, 1))

Если вам действительно нужно увидеть весь массив, используйте функцию numpy.set_printoptions:

np.set_printoptions(threshold=np.nan)

И вообще, с помощью этой функции можно настроить печать массивов «под себя». Функция numpy.set_printoptions принимает несколько аргументов:

precision : количество отображаемых цифр после запятой (по умолчанию 8).

threshold : количество элементов в массиве, вызывающее обрезание элементов (по умолчанию 1000).

edgeitems : количество элементов в начале и в конце каждой размерности массива (по умолчанию 3).

linewidth : количество символов в строке, после которых осуществляется перенос (по умолчанию 75).

suppress : если True, не печатает маленькие значения в scientific notation (по умолчанию False).

nanstr : строковое представление NaN (по умолчанию ‘nan’).

infstr : строковое представление inf (по умолчанию ‘inf’).

formatter : позволяет более тонко управлять печатью массивов. Здесь я его рассматривать не буду, можете почитать здесь (на английском).

И вообще, пользуйтесь официальной документацией по numpy, а в этом пособии я постараюсь описать всё необходимое. В следующей части мы рассмотрим базовые операции над массивами.

Подписывайтесь, чтобы не пропустить 🙂

Создание массива

• из другой структуры python (список, кортеж и других)
• специальными функциями создания (arange, ones, zeros и другие)
• из файла (специальный формат)
• из байт (из строки или буфера)
• специальными функциями (random)

Создаем массив из объектов python функцией array

x = np.array()
x = np.array()
x = np.array(,,(1+1j,3.)]) 

x = np.array(, , ])  

Mesh-grid Arrays

In : x = np.array()     
In : y = np.array()     
In : X, Y = np.meshgrid(x, y)
In : X                             
Out: array(,           
                ,
                ])
In : Y                            
Out: array(,
                ,
                ])
In : Z = (X + Y) ** 2             
In : Z
Out: array(,
                ,
                ])

Создание характерных массивов

In : f = np.indices((3,4))

In : f
Out:
array(,
        ,
        ],

       ,
        ,
        ]])

Массив случайных чисел

равномерное распределение, float

np.random.random_sampleshapeравномерно

>>> np.random.random_sample()          
0.47108547995356098
>>> (np.random.random_sample())    
< ''>
>>> np.random.random_sample((5,))      
array()

(b - a) * random_sample() + a

r = (7 - (-5)) * np.random.random_sample((2, 3)) + (-5)
array(,
       ])

нормальное распределение, float

numpy.random.standard_normal

s = np.random.standard_normal((2, 3))
array(,
       ])

s = np.random.standard_normal()
-0.8945336142780018

равномерное распределение, int

numpy.random.randint

• на [low, hight), если оба определены
• на [0, low) если hight не определено

если size нет, то вернет 1 число

np.random.randint(15)                   
14
np.random.randint(2, size=10)           
array()
np.random.randint(5, 15, size=10)       
array()
np.random.randint(5, size=(2, 4))       
array(,
       ])

Сделаем массив по формуле

In :  f(n,m):
             res = n + 10 * m
              res
In : A = np.fromfunction(f, (6, 6), dtype=)
In : A
Out: array(,
                ,
                ,
                ,
                ,
                ])

realimag

In : d = np.array(, dtype=)
In : d
Out: array()
In : re = d.real
In : re
Out: array()
In : im = d.imag
In : im
Out: array()

In : re = 10                         
In : im = -13
In : d                                  
Out: array() 

Срезы

Часто приходится работать не с целым массивом, а только с некоторыми его элементами. Для этих целей в «Пайтоне» существует метод «Срез» (слайс). Он пришел на замену перебору элементов циклом for.

Метод открывает широкие возможности для получения копии массива в «Питоне». Все манипуляции осуществляются в таком виде . Здесь значение start обозначает индекс элемента, от которого начинается отсчет, значение stop — последний элемент, размер шага — количество пропускаемых элементов при каждой итерации. По умолчанию start равняется нулю, то есть отсчет начинается от нулевого элемента списка, stop равняется индексу последнего элемента в списке, шаг — равен единице, то есть перебирает каждый поочередно. Если передать в функцию без аргументов, список копируется полностью от начала до конца.

Например, у нас есть массив:

mas =

Чтобы его скопировать, используем mas. Функция вернет последовательность элементов . Если аргументом будет отрицательное значение, например -3, функция вернет элементы с индексами от третьего до последнего.

mas; //

После двойного двоеточия указывается шаг элементов, копируемых в массиве. Например, mas вернет массив . Если указано отрицательное значение, например, отсчет будет начинаться с конца, и получим .

Методом среза можно гибко работать с вложенными списками. Для двумерного массива в «Питоне» означает, что вернется каждый третий элемент всех массивов. Если указать — вернутся первые два.

3.4. Суммы, разности, произведения

Произведение элементов массива по заданной оси.

Сумма элементов массива по заданной оси.

Произведение элементов массива по заданной оси в котором элементы NaN учитываются как 1.

Сумма элементов массива по заданной оси в котором элементы NaN учитываются как 0.

Возвращает накопление произведения элементов по заданной оси, т.е. массив в котором каждый элемент является произведением предшествующих ему элементов по заданной оси в исходном массиве.

Возвращает накопление суммы элементов по заданной оси, т.е. массив в котором каждый элемент является суммой предшествующих ему элементов по заданной оси в исходном массиве.

Возвращает накопление произведения элементов по заданной оси, т.е. массив в котором каждый элемент является произведением предшествующих ему элементов по заданной оси в исходном массиве. Элементы NaN в исходном массиве при произведении учитываются как 1.

Возвращает накопление суммы элементов по заданной оси, т.е. массив в котором каждый элемент является суммой предшествующих ему элементов по заданной оси в исходном массиве. Элементы NaN в исходном массиве при суммировании учитываются как 0.

Возвращает n-ю разность вдоль указанной оси.

Разность между последовательными элементами массива.

Дискретный градиент (конечные разности вдоль осей) массива .

Векторное произведение двух векторов.

Интегрирование массива вдоль указанной оси методом трапеций.

Базовые операции

Математические операции над массивами выполняются поэлементно. Создается новый массив, который заполняется результатами действия оператора.

>>> import numpy as np
>>> a = np.array()
>>> b = np.arange(4)
>>> a + b
array()
>>> a - b
array()
>>> a * b
array()
>>> a  b  # При делении на 0 возвращается inf (бесконечность)
array()
<string>:1: RuntimeWarning: divide by zero encountered in true_divide
>>> a ** b
array()
>>> a % b  # При взятии остатка от деления на 0 возвращается 0
<string>:1: RuntimeWarning: divide by zero encountered in remainder
array()

Для этого, естественно, массивы должны быть одинаковых размеров.

>>> c = np.array(, 4, 5, 6]])
>>> d = np.array(, 3, 4], 5, 6]])
>>> c + d
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

Также можно производить математические операции между массивом и числом. В этом случае к каждому элементу прибавляется (или что вы там делаете) это число.

>>> a + 1
array()
>>> a ** 3
array()
>>> a < 35  # И фильтрацию можно проводить
array(, dtype=bool)

NumPy также предоставляет множество математических операций для обработки массивов:

>>> np.cos(a)
array()
>>> np.arctan(a)
array()
>>> np.sinh(a)
array()

Полный список можно посмотреть здесь.

Многие унарные операции, такие как, например, вычисление суммы всех элементов массива, представлены также и в виде методов класса ndarray.

>>> a = np.array(, 4, 5, 6]])
>>> np.sum(a)
21
>>> a.sum()
21
>>> a.min()
1
>>> a.max()
6

По умолчанию, эти операции применяются к массиву, как если бы он был списком чисел, независимо от его формы. Однако, указав параметр axis, можно применить операцию для указанной оси массива:

Функции интерполяции

В сфере числового анализа интерполяция — это построение новых точек данных на основе известных. Библиотека SciPy включает подпакет scipy.interpolate, состоящий из сплайновых функций и классов, одно- и многомерных интерполяционных классов и так далее.

Одномерная интерполяция

Одномерная интерполяция — это область построения кривой, которая бы полностью соответствовала набору двумерных точек данных. В SciPy есть функция , которая используется для создания одномерной интерполяции.

Пример:

Вывод:

Многомерная интерполяция

Многомерная интерполяция (пространственная интерполяция) — это тип интерполяции функций, который состоит из более чем одной переменной. Следующий пример демонстрирует работу функции .

При интерполяции на двумерную сетку функция использует массивы x, y и z для приближения функции и возвращает функцию, у которой вызываемый метод использует сплайновую интерполяцию для поиска значения новых точек.

Пример:

Вывод:

Создание векторов и матриц

Вектора и матрицы – это основные объекты, которыми приходится оперировать в машинном обучении. Numpy предоставляет довольно много удобных функций, которые строят эти объекты.

Перед тем как их использовать не забудьте импортировать Numpy в проект.

>>>import numpy as np

np.arange()

Функция arange() аналогична по своему назначению функции range() из стандартной библиотеки Python. Ее основное отличие заключается в том, что arange() позволяет строить вектор с указанием шага в виде десятичной дроби.

Синтаксис использования функции следующий:

arange(stop)

arange(start, stop)

arange(start, stop, step)

В первом варианте будет создан вектор из целых чисел от 0 до stop.

>>> np.arange(10)
array()

Второй вариант позволяет задавать интервал, в этом случае вектор также будет содержать целые числа.

>>> np.arange(5, 12)
array()

Третий вариант позволяет определить интервал чисел и шаг, который может быть десятичным числом

>>> np.arange(1, 5, 0.5)
array()

np.matrix()

Matrix является удобным инструментом для задания матрицы. При этом можно использовать Matlab стиль, либо передать в качестве аргумента список Python (или массив Numpy).

Вариант со списком Python.

>>> a = , ]
>>> np.matrix(a)
matrix(,
       ])

Вариант с массивом Numpy.

>>> b = np.array(, ])
>>> np.matrix(b)
matrix(,
       ])

Вариант в Matlab стиле.

>>> np.matrix('')
matrix(,
       ])

np.zeros(), np.eye()

В арсенале Numpy есть функции для создания специальных матриц: нулевых и единичных. Нулевой называется матрица, состоящая полностью из нулей. Для ее создания удобно использовать функцию zeros(), в качестве аргумента в нее передается кортеж из двух элементов, первый из них – это количество строк, второй – столбцов.

>>> np.zeros((3, 4))
array(,
      ,
      ])

Функция eye() создает единичную матрицу – квадратную матрицу, у которой элементы главной диагонали равны единицы, все остальные – нулю.

>>> np.eye(3)
array(,
      ,
      ])

Сортировка, поиск, подсчет¶

Создание матрицы

Вариант 1: Строгое задание элементов матрицы

arr = ,
         ]

arr = , ]

Вариант 2. Создание в памяти матрицы заданного размера, заполненной некоторыми начальными значениями (например, нулями)
НЕВЕРНЫЙ способ (так делать точно не надо)

row =  * M 

A =  * N 

ДЕЛАЕМ ПРАВИЛЬНО!
Чтобы создать правильно матрицу, необходимо заставить компилятор создать все строки в памяти как разные объекты.
Для этого необходимо сначала создать пустой список, а затем в цикле добавлять к нему новые строки с помощью метода

N = 3
M = 2
A = []
for i in range(N):
    A.append(*M)

сделать то же самое можно с помощью генератора

N = 3
M = 2
A = *M for i in range(N) ]

Заполнение матрицы произвольными значениями

После создания матрицы можно заполнить ее произвольными значениями. Так как каждый элемент имеет два индекса, то необходимо использовать вложенные циклы

for i in range(N):
    for j in range(M):
        A = ...

Вывод матрицы на экран

Вариант 1. Простейший способ
Вывод матрицы в одну строку

print(A)

Вариант 2.

Для обработки и вывода списка, как правило, используется два вложенных цикла. Первый цикл по номеру строки, второй цикл — по элементам внутри строки.
Для того, чтобы вывести матрицу на экран построчно, разделяя числа пробелами внутри одной строки, необходимо написать такой фрагмент:

for i in range(len(A)):                 # len(A) - возвращает количество строк в матрице А
    for j in range(len(A)):           # len(A) - возвращает количество элементов в строке i
        print(A, end = ' ')
    print()                             # делаем переход на новую строку после вывода на экран строки

То же самое, но циклы не по индексу, а по значениям списка (цикл for умеет делать перебор всех элементов в списке (массиве), строке):

for row in A:                          # делаем перебор всех строк матрицы A
    for elem in row:                   # перебираем все элементы в строке row
        print(elem, end = ' ')
    print()

Для вывода одной строки можно воспользоваться методом :

for row in A:
    print(' '.join(list(map(str, row))))

Функции (методы) для расчета статистик в Numpy

Ниже, в таблице, приведены методы объекта ndarray (или matrix), которые, как мы помним из раздела выше, могут быть также вызваны как функции библиотеки Numpy, для расчета статистик по данным массива.

Вычислим некоторые из представленных выше статистик.

>>> m.mean()
4.833333333333333
>>> m.mean(axis=1)
matrix(,
        ,
        ])
>>> m.sum()
58
>>> m.sum(axis=0)
matrix(])

Пакеты в SciPy

В SciPy есть набор пакетов для разных научных вычислений:

Подробное описание можно найти в официальной документации.

Эти пакеты нужно импортировать для использования библиотеки. Например:

Прежде чем рассматривать каждую функцию в подробностях, разберемся с теми из них, которые являются одинаковыми в NumPy и SciPy.

Изменяем количество строк матрицы. Данные не меняются

ravel, reshape, T

In :  numpy as np

In : a = np.array(,
   ...: 
   ...: ])

In : a
Out:
array(,
       ])

In : a.shape
Out: (2, 3)

In : a.ravel()                 
Out: array()

In : a.reshape(3,2)           
Out:
array(,
       ,
       ])

In : a.reshape(3, -1)        
Out:
array(,
       ,
       ])


In : a.T                      
Out:
array(,
       ,
       ])

In : np.transpose(a)          
Out:
array(,
       ,
       ])

vstack, hstack, вектор строкой и столбцом, column_stack

In : b = np.array()     
Out: array()

In : v = b           
Out:
array(,
       ,
       ,
       ])

In : bm = np.vstack((b, b, b))       
Out:
array(,
       ,
       ])

In : bs = np.hstack((b, b, b))       
Out: array()

In : np.column_stack((b, b))         
Out:
array(,
       ,
       ,
       ])

In : a1 =  np.array(, ])
Out:
array(,
       ])

In : a2 = np.array(])
Out: array(])

In : np.concatenate((a1, a2), axis= 0)     
Out:
array(,
       ,
       ])

In : a2.T                                  
Out:
array(,
       ])

In : np.concatenate((a1, a2.T), axis= 1)  
Out:
array(,
       ])

np.hsplit

np.vsplit

делим НА 3 части

np.hsplit(массив, n)

In : a = np.arange(1, 25)
Out:
array()

In : a1 = a.reshape((2, 12))
Out:
array(,
       ])

In : np.hsplit(a1, 3)                              
Out:
,
        ]), array(,
        ]), array(,
        ])]

In : s1 = np.hsplit(a1, 3)                         

In : s1                                         
Out:
array(,
       ])

In : s1                                         
Out:
array(,
       ])

In : s1                                         
Out:
array(,
       ])

делим ПОСЛЕ столбцов номер (n1, n2, n3 и далее)

np.hsplit(массив, (3, 4))

In : a = np.arange(1, 25)
Out:
array()

In : a1 = a.reshape((2, 12))
Out:
array(,
       ])

In : w1 = np.hsplit(a1, (3, 4))

In : w1
Out:
,
        ]), array(,
        ]), array(,
        ])]

In : w1
Out:
array(,
       ])

In : w1
Out:
array(,
       ])

In : w1
Out:
array(,
       ])

Table of Rough MATLAB-NumPy Equivalents¶

The table below gives rough equivalents for some common MATLAB
expressions. These are not exact equivalents, but rather should be
taken as hints to get you going in the right direction. For more detail
read the built-in documentation on the NumPy functions.

In the table below, it is assumed that you have executed the following
commands in Python:

from numpy import *
import scipy.linalg

Also assume below that if the Notes talk about “matrix” that the
arguments are two-dimensional entities.

General Purpose Equivalents

Навигация по записям

Runtastic

Примеры работы с NumPy

Подытожим все вышесказанное. Вот несколько примеров полезных инструментов NumPy, которые могут значительно облегчить процесс написания кода.

Математические формулы NumPy

Необходимость внедрения математических формул, которые будут работать с матрицами и векторами, является главной причиной использования NumPy. Именно поэтому NumPy пользуется большой популярностью среди представителей науки. В качестве примера рассмотрим формулу , которая является центральной для контролируемых моделей машинного обучения, что решают проблемы регрессии:

Реализовать данную формулу в NumPy довольно легко:

Главное достоинство NumPy в том, что его не заботит, если и содержат одно или тысячи значение (до тех пор, пока они оба одного размера). Рассмотрим пример, последовательно изучив четыре операции в следующей строке кода:

У обоих векторов и по три значения. Это значит, что в данном случае равно трем. После выполнения указанного выше вычитания мы получим значения, которые будут выглядеть следующим образом:

Затем мы можем возвести значения вектора в квадрат:

Теперь мы вычисляем эти значения:

Таким образом мы получаем значение ошибки некого прогноза и за качество модели.

Представление данных NumPy

Задумайтесь о всех тех типах данных, которыми вам понадобится оперировать, создавая различные модели работы (электронные таблицы, изображения, аудио и так далее). Очень многие типы могут быть представлены как n-мерные массивы:

7.4. Генерация случайных значений

Очень многие вычислительные методы требуют генерации случайных значений. В некоторых ситуациях, на генерируемые данные накладываются очень строгие и высокие требования. NumPy содержит функции для генерации простых случайных данных, функции генерации случайных перестановок, а так же большое количество функций для гернерации случайных чисел с всевозможными вероятностными распределениями.

Получение простых случайных данных:

Перестановки:

NumPy предоставляет порядка 30 функций, позволяющих генерировать случайные числа с самыми разными вероятностными распределениями:

Вы так же имеете доступ к состоянию генератора случайных чисел, а так же можете управлять им:

Создание, вывод и ввод матрицы в Питоне

• Таким образом, получается структура из вложенных списков, количество которых определяет количество строк матрицы, а число элементов внутри каждого вложенного списка указывает на количество столбцов в исходной матрице.

Рассмотрим пример матрицы размера 4 х 3:

matrix = -1, , 1, 
    -1, , 1, 
    , 1, -1,
    1, 1, -1

Данный оператор можно записать в одну строку:

matrix = -1, , 1, -1, , 1, , 1, -1, 1, 1, -1

Вывод матрицы можно осуществить одним оператором, но такой простой способ не позволяет выполнять какой-то предварительной обработки элементов:

print(matrix)

Результат: 

Для вывода матрицы в виде таблицы можно использовать специально заготовленную для этого процедуру:

1. способ:

1
2
3
4
5

def printMatrix ( matrix ): 
   for i in range ( len(matrix) ): 
      for j in range ( len(matrixi) ): 
          print ( "{:4d}".format(matrixij), end = "" ) 
      print ()

В примере i – это номер строки, а j – номер столбца;len(matrix) – число строк в матрице.

способ:

1
2
3
4
5

def printMatrix ( matrix ): 
   for row in matrix: 
      for x in row: 
          print ( "{:4d}".format(x), end = "" ) 
      print ()

Внешний цикл проходит по строкам матрицы (row), а внутренний цикл проходит по элементам каждой строки (x).

Для инициализации элементов матрицы случайными числами используется алгоритм:

1
2
3
4
5
6

import random 
for i in range(N): 
    for j in range(M): 
       matrixij = random.randint ( 30, 60 )
       print ( "{:4d}".format(matrixij), end = "" ) 
    print()