Как создать нулевую матрицу python
Перейти к содержимому

Как создать нулевую матрицу python

  • автор:

Как в Питоне создать матрицу?

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

Прежде чем мы начнем, важно упомянуть, что Python не имеет встроенной поддержки матриц, подобных языкам, которые позволяют нам создавать многомерные массивы (C, C++, Java и т.д.). Python обеспечивает аналогичное поведение с использованием вложенных списков.

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

Массивы

Рассмотрим последовательность из четырех чисел:

1 2 3 4

Давайте назовем эту последовательность A. Последовательность A обычно называется массивом, представленным в Python с помощью списка или кортежа. Этот массив A имеет длину 4. Мы обозначим его длину через n. Итак, для A n = 4. Приведенный ниже код показывает пример использования как списка, так и кортежа.

A = [1, 2, 3, 4] # список (list) A = (1, 2, 3, 4) # кортеж (tuple)

В Python, если мы хотим получить доступ к отдельному элементу этого массива или сослаться на него, это делается с помощью числа, называемого индексом, для обозначения положения этого элемента в массиве. Индексы в Python начинаются с нуля. Для приведенного выше списка / кортежа индекс первого элемента равен 0, а последнего – 3. Приведенный ниже код выводит все элементы из списка с использованием индексов.

A = [1, 2, 3, 4] print(A[0]) print(A[1]) print(A[2]) print(A[3]) '''результат''': 1 2 3 4

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

A = [1, 2, 3, 4] '''цикл по элементам массива''' for x in A: print(x) '''или цикл по индексам массива''' for i in range(len(A)): print(A[i]) '''обращаемся по индексу к элементу массива''' '''результат''': 1 2 3 4 1 2 3 4

Матрицы

Матрица – это последовательность чисел, которая содержит два измерения. В отличие от массивов (также называемых векторами в математике), которые имеют одно измерение, то есть свою длину или размер, матрица имеет строки и столбцы. Матрица выглядит как прямоугольный блок чисел, содержащий m строк и n столбцов.

Пример матрицы:

Назовем матрицу выше – М. Матрица M имеет 3 строки и 3 столбца. Первая строка, содержащая [10 20 30], и первый столбец, содержащий [10 -5 1]. M – это матрица размерностью 3 x 3 (3 на 3).

Доступ к элементам матрицы

Для доступа к одному элементу требуется указать индекс строки и индекс столбца. Итак, для ссылки на элемент в первой строке и первом столбце матрицы M мы напишем M₁₁ = 10

В общем случае формат – Mᵢⱼ, где i – номер строки, а j – номер столбца. В математике номера строк и столбцов начинаются с 1, а не с нуля (как в Питоне).

Вернемся к Python. Для хранения матрицы, нам нужно создать список состоящий из списков:

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ]

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

Таким образом, к первому элементу (верхнему левому) можно получить доступ как к M[0][0], а к последнему – как к M[2][2].

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] print(M[0][0]) print(M[2][2]) ''' напечатается: 10 8 '''

Чтобы вывести количество строк и столбцов, используйте функцию len().

Для строк получаем len() всей матрицы M, так как количество строк равно количеству списков во внешнем списке. Для столбцов нужно вызвать функцию len() для внутреннего списка.

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] print('Rows: ', len(M)) print('Columns: ', len(M[0])) print('Matrix size: ', len(M), 'x', len(M[0])) ''' напечатается: Rows: 3 Columns: 3 Matrix size: 3 x 3 '''

Чтобы получить доступ к одной целой строке, скажем, ко второй (т.е. к индексу 1), нужно сделать следующее:

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] print(M[1]) ''' напечатается: [-5, 15, 40] '''

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

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] for i in range(len(M)): print(M[i][0]) ''' напечатается: 10 -5 1 '''

Приведенный ниже код печатает все элементы матрицы M:

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] for i in range( len(M) ): ''' индексы строк от 0 до 2 ''' for j in range( len(M[i]) ): ''' индексы столбцов от 0 до 2 ''' print( M[i][j] ) ''' напечатается: 10 20 30 -5 15 40 1 7 8 '''

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

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] for i in range( len(M) ): for j in range( len(M[i]) ): ''' вместо новой строки печатаем пробел ''' print( M[i][j] , end = ' ') ''' переход на новую строку после печати строки матрицы ''' print() ''' напечатается: 10 20 30 -5 15 40 1 7 8 '''

Если вы не понимаете приведенные выше вложенные циклы, посмотрите измененный код ниже, который печатает индексы вместо данных. Это поможет понять, как работают с индексами в матрицах.

M = [ [10, 20, 30], [-5, 15, 40], [1, 7, 8] ] for i in range( len(M) ): for j in range( len(M[i]) ): ''' печать индексов: ''' print( (i,j) , end = ' ') print() ''' напечатается: (0, 0) (0, 1) (0, 2) (1, 0) (1, 1) (1, 2) (2, 0) (2, 1) (2, 2) '''

Специальные виды матриц

Можно выделить следующие виды матриц, основываясь на их размерностях:

Квадратная матрица

Квадратная матрица – это матрица, имеющая одинаковое количество строк и столбцов.
Есть несколько свойств, связанных с квадратными матрицами, которые мы увидим в следующих разделах.

Вектор-строка

Вектор строка – это матрица, в которой количество строк равно единице, т.е. матрица размерностью 1 x n.

Но представление с помощью списков Пайтон может быть немного сложным. Мы представим его в виде списка, содержащего один вложенный список:

row_vector = [ [10, 20, 30] ]

Вектор-столбец

Теперь очевидно, что матрица с одним столбцом, но с несколькими строками станет вектором-столбцом. т.е. размер будет m x 1

col = [[10], [20], [30]]

Это был краткий экскурс в мир матриц Питона.

В следующих статьях этого цикла мы рассмотрим более подробно работу с матрицами.

Как работать с матрицами в Python

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

Матрицы и библиотека NumPy

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

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

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

Подключение библиотеки NumPy

NumPy не встроена в интерпретатор Python, поэтому перед импортом её необходимо установить. Для этого в можно воспользоваться утилитой pip. Введите в консоле команду:

pip install numpy

Теперь, когда библиотека установлена, её можно подключить с помощью команды import . Для удобства переименуем numpy при импорте в np следующим образом:

import numpy as np

Ниже в примерах будет использован именно такой импорт, поэтому обращение к библиотеке будет через np , а не numpy !

Создание

Для создании матрицы используется функция array(). В функцию передаётся список. Вот пример создания, мы подаём в качестве аргумента функции двумерный список:

a = np.array([[3, 3, 3], [2, 5, 5]])

Вторым параметром можно задать тип элементов матрицы:

a = np.array([[3, 3, 3],[2, 5, 5]], int) print(a)

Тогда в консоль выведется:

[[3 3 3] [2 5 5]]

Обратите внимание, что если изменить int на str, то тип элементов изменился на строковый. Кроме того, при выводе в консоль NumPy автоматически отформатировал вывод, чтобы он выглядел как матрица, а элементы располагались друг под другом.

В качестве типов элементов можно использовать int, float, bool, complex, bytes, str, buffers. Также можно использовать и другие типы NumPy: логические, целочисленные, беззнаковые целочисленные, вещественные, комплексные. Вот несколько примеров:

  • np.bool8 — логическая переменная, которая занимает 1 байт памяти.
  • np.int64 — целое число, занимающее 8 байт.
  • np.uint16 — беззнаковое целое число, занимающее 2 байта в памяти.
  • np.float32 — вещественное число, занимающее 4 байта в памяти.
  • np.complex64 — комплексное число, состоящее из 4 байтового вещественного числа действительной части и 4 байтов мнимой.

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

size = a.shape print(size) # Выведет (2, 3)

Первое число (2) — количество строк, второе число (3) — количество столбцов.

Нулевая матрица

Если необходимо создать матрицу, состоящую только из нулей, используйте функцию zeros():

a_of_zeros = np.zeros((2,2)) print(a_of_zeros)

Результат этого кода будет следующий:

[[0. 0.] [0. 0.]]

Получение строки, столбца и элемента

Чтобы получить строку двухмерной матрицы, нужно просто обратиться к ней по индексу следующим образом:

temp = a[0] print(temp) #Выведет [3 3 3]

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

arr = np.array([[3,3,3],[2,5,5]], str) temp = arr[:,2] print(temp) # Выведет ['3' '5']

Чтобы получить элемент, нужно указать номер столбца и строки, в которых он находится. Например, элемент во 2 строке и 3 столбце — это 5, проверяем (помним, что нумерация начинается с 0):

arr = np.array([[3,3,3],[2,5,5]], str) temp = arr[1][2] print(temp) # Выведет 5

Умножение и сложение

Чтобы сложить матрицы, нужно сложить все их соответствующие элементы. В Python для их сложения используется обычный оператор «+».

Пример сложения:

arr1 = np.array([[3,3,3],[2,5,5]]) arr2 = np.array([[2,4,2],[1,3,8]]) temp = arr1 + arr2 print(temp)

Результирующая матрица будет равна:

[[ 5 7 5] [ 3 8 13]]

Важно помнить, что складывать можно только матрицы с одинаковым количеством строк и столбцов, иначе программа на Python завершится с исключением ValueError.

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

Умножение в NumPy выполняется с помощью метода dot().

Пример умножения:

arr1 = np.array([[3,3],[2,5]]) arr2 = np.array([[2,4],[1,3]]) temp = arr1.dot(arr2) print(temp)

Результат выполнения этого кода будет следующий:

[[ 9 21] [ 9 23]]

Как она получилась? Разберём число 21, его позиция это 1 строка и 2 столбец, тогда мы берем 1 строку первой матрицы и умножаем на 2 столбец второй. Причём элементы умножаются позиционно, то есть 1 на 1 и 2 на 2, а результаты складываются: [3,3] * [4,3] = 3 * 4 + 3 * 3 = 21.

Транспонированная и обратная

Транспонированная матрица — это матрица, у которой строки и столбцы поменялись местами. В библиотеки NumPy для транспонирования двумерных матриц используется метод transpose(). Пример:

arr1 = np.array([[3,3],[2,5]]) temp = arr1.transpose() print(temp)

В результате получится матрица:

[[3 2] [3 5]]

Чтобы получить обратную матрицу, необходимо использовать модуль linalg (линейная алгебра). Используем функцию inv():

arr1 = np.array([[3,3],[2,5]]) temp = np.linalg.inv(arr1) print(temp)

Результирующая матрица будет равна:

[[ 0.55555556 -0.33333333] [-0.22222222 0.33333333]]

Получение максимального и минимального элемента

Чтобы получить максимальный или минимальный элемент, можно пройтись по всем элементам матрицы с помощью двух циклов for . Это стандартный алгоритм перебора, который известен почти каждому программисту:

arr = np.array([[3,3],[2,5]]) min = arr[0][0] for i in range(arr.shape[0]): for j in range(arr.shape[1]): if min > arr[i][j]: min = arr[i][j] print("Минимальный элемент:", min) # Выведет "Минимальный элемент: 2"

NumPy позволяет найти максимальный и минимальный элемент с помощью функций amax() и amin(). В качестве аргумента в функции нужно передать саму матрицу. Пример:

arr1 = np.array([[3,3],[2,5]]) min = np.amin(arr1) max = np.amax(arr1) print("Минимальный элемент:", min) # Выведет "Минимальный элемент: 2" print("Максимальный элемент:", max) # Выведет "Максимальный элемент: 5"

Как видим, результаты реализации на чистом Python и реализации с использованием библиотеки NumPy совпадают.

Заключение

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

Python. Как создать матрицу?

Добрый день всем. Учусь на заочном отделении.Помогите одолеть задачу.Пытаюсь разобраться в языке Python.
Задача звучит так:
Создать целочисленную матрицу А размером МxN и заполнить ее однозначными случайными числами из диапазона от 0 до 9. Матрица должна иметь тип int[,]. Значения М и N вводятся с клавиатуры. Исходную матрицу построчно выдать на экран.
Исключить из матрицы первую строку, имеющую максимальную сумму ее элементов. Новую матрицу построчно выдать на экран. Определение номера первой строки, имеющей максимальную сумму ее элементов, оформить в виде функции.

Буду благодарна за любую подсказку

  • Вопрос задан более трёх лет назад
  • 60261 просмотр

Комментировать
Решения вопроса 0
Ответы на вопрос 3

fox_12

Владимир Куц @fox_12 Куратор тега Python
Расставляю биты, управляю заряженными частицами

>>> import random >>> M,N = 5,6 >>> matrix = [[random.randrange(0,10) for y in range(M)] for x in range(N)] >>> matrix [[0, 3, 1, 3, 5], [5, 8, 8, 0, 5], [8, 9, 8, 5, 2], [7, 7, 3, 9, 9], [0, 1, 1, 3, 8], [5, 1, 1, 4, 6]] >>> for im in range(N): . print matrix[im] . [0, 3, 1, 3, 5] [5, 8, 8, 0, 5] [8, 9, 8, 5, 2] [7, 7, 3, 9, 9] [0, 1, 1, 3, 8] [5, 1, 1, 4, 6] >>> def find_max(m): . max_sum = 0 . index = -1 . for x in range(N): . if sum(m[x])>max_sum: . max_sum=sum(m[x]) . index=x . return max_sum, index . >>> find_max(matrix) (35, 3) >>> max_value,index = find_max(matrix) >>> matrix.remove(matrix[index]) >>> for im in range(N): . print matrix[im] . [0, 3, 1, 3, 5] [5, 8, 8, 0, 5] [8, 9, 8, 5, 2] [0, 1, 1, 3, 8] [5, 1, 1, 4, 6]

ввод с клавиатуры и оформление в виде кода, надеюсь, сделаете сами

Ответ написан более трёх лет назад
Комментировать
Нравится 2 Комментировать

alexsurfer

Алексей Перминов @alexsurfer
Программист Python, Django, PostgreSQL, Golang.
Переписал решение в ООП стиле:

import random class Matrix: def __init__(self, row, col): self.n = row self.matrix = [[random.randrange(0, 10) for a in range(col)] for b in range(row)] def print(self): matrix = self.matrix for im in range(len(matrix)): print(matrix[im]) def find_max(self): max_sum = 0 n = self.n m = self.matrix index = -1 for x in range(n): if sum(m[x]) > max_sum: max_sum = sum(m[x]) index = x print("максимум: %s, индекс: %s" % (max_sum, index)) return max_sum, index def remove_max_row(self): matrix = self.matrix n = self.n max_value, index = self.find_max() matrix.remove(matrix[index]) for im in range(n-1): print(matrix[im]) Matrix(5, 5).print() print('-'*100) Matrix(5, 5).find_max() print('='*100) Matrix(5, 5).remove_max_row()

Ответ написан более трёх лет назад
Комментировать
Нравится 1 Комментировать
programmer1503 @programmer1503

вместо ошибок с созданием матрицы 3 раза при использовании класса
d=Matrix(5, 5);
d.print()
print(‘-‘*100)
#Matrix(5, 5).find_max()
print(‘=’*100)
d.remove_max_row()

Ответ написан более трёх лет назад
Комментировать
Нравится Комментировать
Ваш ответ на вопрос

Войдите, чтобы написать ответ

python

  • Python
  • +3 ещё

В боте когда я меняю переменую many += 1 выводиться ошибка?

  • 1 подписчик
  • 22 минуты назад
  • 11 просмотров

Линейная алгебра на Python. [Урок 1]. Создание Матрицы. Общие понятия

Follow us on Google Plus Follow us on rss

Эта статья открывает список уроков на тему “Линейная алгебра с примерами на Python . Мы постараемся рассказать о базовых понятиях линейной алгебры, которые могут быть полезны тем, кто занимается машинным обучением и анализом данных, и будем сопровождать все это примерами на языке Python .

  • Матрицы
    • Виды матриц и способы их создания в Python
    • Вектор
      • Вектор-строка
      • Вектор-столбец

      Матрицы

      Матрицей в математике называют объект, записываемый в виде прямоугольной таблицы, элементами которой являются числа (могут быть как действительные, так и комплексные). Пример матрицы приведен ниже.

      В общем виде матрица записывается так:

      Представленная выше матрица состоит из i-строк и j-столбцов. Каждый ее элемент имеет соответствующее позиционное обозначение, определяемое номером строки и столбца на пересечении которых он расположен: \(a_\)- находится на i-ой строке и j-м столбце.

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

      Виды матриц и способы их создания в Python

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

      Напомним, для того, чтобы использовать библиотеку Numpy ее нужно предварительно установить, после этого можно импортировать в свой проект. По установке Numpy можно подробно прочитать в разделе “Установка библиотеки Numpy” из введения. Для того чтобы импортировать данный модуль, добавьте в самое начало программы следующую строку

      import numpy as np

      Если после импорта не было сообщений об ошибке, то значит все прошло удачно и можно начинать работу. Numpy содержит большое количество функций для работы с матрицами, которые мы будем активно использовать. Обязательно убедитесь в том, что библиотека установлена и импортируется в проект без ошибок.

      Рассмотрим, различные варианты матриц и способы их задания в Python .

      Вектор

      Вектором называется матрица, у которой есть только один столбец или одна строка. Более подробно свойства векторов, их геометрическая интерпретация и операции над ними будут рассмотрены в “ Главе 2 Векторная алгебра” .

      Вектор-строка

      Вектор-строка имеет следующую математическую запись.

      Такой вектор в Python можно задать следующим образом.

      >>> v_hor_np = np.array([1, 2]) >>> print(v_hor_np ) [1 2]

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

      Создадим нулевую вектор-строку размера 5 .

      >>> v_hor_zeros_v1 = np.zeros((5,)) >>> print(v_hor_zeros_v1 ) [0. 0. 0. 0. 0.]

      В случае, если требуется построить вектор-строку так, чтобы она сама являлась элементом какого-то массива, это нужно для возможности транспонирования матрицы (см. раздел “ 1.3 Транспонирование матрицы” ), то данную задачу можно решить так.

      >>> v_hor_zeros_v2 = np.zeros((1, 5)) >>> print(v_hor_zeros_v2 ) [[0. 0. 0. 0. 0.]]

      Построим единичную вектор-строку в обоих из представленных для нулевого вектора-строки форм.

      >>> v_hor_one_v1 = np.ones((5,)) >>> print(v_hor_one_v1) [1. 1. 1. 1. 1.]
      >>> v_hor_one_v2 = np.ones((1, 5)) >>> print(v_hor_one_v2) [[1. 1. 1. 1. 1.]]
      Вектор-столбец

      Вектор-столбец имеет следующую математическую запись.

      В общем виде вектор столбец можно задать следующим образом.

      >>> v_vert_np = np.array([[1], [2]]) >>> print(v_vert_np) [[1] [2]]

      Рассмотрим способы создания нулевых и единичных векторов-столбцов. Построим нулевой вектор-столбец .

      >>> v_vert_zeros = np.zeros((5, 1)) >>> print(v_vert_zeros) [[0.] [0.] [0.] [0.] [0.]]

      Единичный вектор-столбец можно создать с помощью функции ones() .

      >>> v_vert_ones = np.ones((5, 1)) >>> print(v_vert_ones) [[1.] [1.] [1.] [1.] [1.]]

      Квадратная матрица

      Довольно часто, на практике, приходится работать с квадратными матрицами . Квадратной называется матрица, у которой количество столбцов и строк совпадает. В общем виде они выглядят так.

      Создадим следующую матрицу.

      В Numpy можно создать квадратную матрицу с помощью метода array() .

      >>> m_sqr_arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print(m_sqr_arr) [[1 2 3] [4 5 6] [7 8 9]]

      Как вы уже наверное заметили, аргументом функции np.array() является список Python , его можно создать отдельно и передать в функцию.

      >>> m_sqr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> m_sqr_arr = np.array(m_sqr) >>> print(m_sqr_arr) [[1 2 3] [4 5 6] [7 8 9]]

      Но в Numpy есть еще одни способ создания матриц – это построение объекта типа matrix с помощью одноименного метода. Задать матрицу можно в виде списка.

      >>> m_sqr_mx = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print(m_sqr_mx) [[1 2 3] [4 5 6] [7 8 9]]

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

      >>> m_sqr_mx = np.matrix('1 2 3; 4 5 6; 7 8 9') >>> print(m_sqr_mx) [[1 2 3] [4 5 6] [7 8 9]]

      Диагональная матрица

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

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

      >>> m_diag = [[1, 0, 0], [0, 5, 0], [0, 0, 9]] >>> m_diag_np = np.matrix(m_diag) >>> print(m_diag_np) [[1 0 0] [0 5 0] [0 0 9]]

      Библиотека Numpy предоставляет инструменты, которые могут упростить построение такой матрицы.

      Первый вариант подойдет в том случае, если у вас уже есть матрица, и вы хотите сделать из нее диагональную. Создадим матрицу размера 3 3 .

      >>> m_sqr_mx = np.matrix('1 2 3; 4 5 6; 7 8 9')

      Извлечем ее главную диагональ.

      >>> diag = np.diag(m_sqr_mx) >>> print(diag) [1 5 9]

      Построим диагональную матрицу на базе полученной диагонали.

      >>> m_diag_np = np.diag(np.diag(m_sqr_mx)) >>> print(m_diag_np) [[1 0 0] [0 5 0] [0 0 9]]

      Второй вариант подразумевает построение единичной матрицы, ей будет посвящен следующий параграф.

      Единичная матрица

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

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

      >>> m_e = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] >>> m_e_np = np.matrix(m_e) >>> print(m_e_np) [[1 0 0] [0 1 0] [0 0 1]]

      Такой способ не очень удобен, к счастью для нас, для построения такого типа матриц в библиотеке Numpy есть специальная функция – eye() .

      >>> m_eye = np.eye(3) >>> print(m_eye) [[ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]]

      В качестве аргумента функции передается размерность матрицы, в нашем примере – это матрица 3 3 . Тот же результат можно получить с помощью функции identity() .

      >>> m_idnt = np.identity(3) >>> print(m_idnt) [[ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]]

      Нулевая матрица

      У нулевой матрицы все элементы равны нулю.

      Пример того, как создать такую матрицу с использованием списков, мы приводить не будем, он делается по аналогии с предыдущим разделом. Что касается Numpy , то в составе этой библиотеки есть функция zeros() , которая создает нужную нам матрицу.

      >>> m_zeros = np.zeros((3, 3)) >>> print(m_zeros) [[ 0. 0. 0.] [ 0. 0. 0.] [ 0. 0. 0.]]

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

      Задание матрицы в общем виде

      Если у вас уже есть данные о содержимом матрицы, то создать ее можно используя списки Python или функцию matrix() из библиотеки Numpy .

      >>> m_mx = np.matrix('1 2 3; 4 5 6') >>> print(m_mx) [[1 2 3] [4 5 6]]

      Если же вы хотите создать матрицу заданного размера с произвольным содержимым, чтобы потом ее заполнить, проще всего для того использовать функцию zeros() , которая создаст матрицу заданного размера, заполненную нулями.

      >>> m_var = np.zeros((2, 5)) >>> print(m_var) [[ 0. 0. 0. 0. 0.] [ 0. 0. 0. 0. 0.]]

      P.S.

      Вводные уроки по “Линейной алгебре на Python” вы можете найти соответствующей странице нашего сайта . Все уроки по этой теме собраны в книге “Линейная алгебра на Python”.

      Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. Для начала вы можете познакомиться с вводными уроками. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *