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

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

В этой статье мы рассмотрим все концепции работы с матрицами в 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

Изучать новое можно по-разному. Одним нравится сначала штудировать теорию, а потом применять её на практике. Другие предпочитают учиться исключительно на примерах, найденных на любимом Stackoverflow. А кто-то вообще загружает навыки управления вертолётом и технику боевых единоборств по выделенному каналу прямо в мозг.

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

Изображение: Wikimedia Commons

Определяем цели

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

Почему бы не взять всё это в свои руки и не начать придумывать упражнения самостоятельно? Да хоть бы и написать свою маленькую личную «Матрицу». Конечно, не ту, в которой будут небоскрёбы, стильные телефоны той эпохи и вездесущие непобедимые агенты Смиты. Для этого нам нужно ещё пару-тройку месяцев поучиться. Но любому начинающему программисту под силу написать модель культовой заставки со стекающими по экрану зелёными струйками цифр. Этим и займёмся.

Запрограммировать такую заставку можно практически на любом языке. Попробуем это сделать на «великом и могучем» Python.

Пишем техническое задание

Для начала определимся, что же мы хотим в итоге получить. Напишем сами себе небольшое техническое задание — всегда полезно. Подумайте про «Матрицу», и память сама подскажет образ — тёмное консольное окно, в котором будут стекать струйки зелёных цифр. Чтобы было интереснее, пусть они двигаются с разной скоростью. У каждой струйки должны быть начало — яркий зелёный ноль — и конец. Кстати, пусть скорости движения начала и конца струйки тоже будут разными и определяются случайным образом.

Звучит не так и сложно. Теперь дело за малым — всего лишь написать код. Приступим.

Готовим инструменты

Как полагается, подключим все необходимые модули. Сначала стандартные:

import sys
import random
import time

Для работы с консолью Windows нам понадобятся модули bext и colorama. Как их установить с помощью pip, вы уже, наверняка, знаете. Нужно их подключить. Но сделаем это по всем правилам — с проверкой:

try:
    import bext, colorama
except ImportError:
    print ('Для запуска программы нужны модули bext и colorama.')
    sys.exit ()

Подготовим к работе консоль:

bext. title ('Matrix') # Меняем заголовок консольного окна
bext.clear () # Очищаем консольное окно
bext.hide () # Скрываем курсор в консольном окне
width, height = bext.size () # Получаем размер консольного окна
width -= 1
height -= 1

Теперь осталось только завести константы с цветами для модуля colorama. Нам нужен зелёный и тёмно-зелёный:

lgreen = colorama.Fore.LIGHTGREEN_EX
green = colorama.Fore.GREEN

Windows — штука хитрая и противоречивая. Базовый цвет green в консоли — это тёмно-зелёный.

Изобретаем антиматерию

Теперь подумаем над самым главным вопросом: как же нам запрограммировать стекающие капли «Матрицы»? Каждая капля — это объект. Все капли разные, но ведут себя одинаково. Поэтому нам надо создать класс, в котором мы опишем основные действия с каплей и все её атрибуты.

Чтобы капли стекали с разной скоростью, зададим каждой из них случайный тайм-аут задержки — в шагах. Какие-то капли будут перемещаться на каждом шаге обновления нашей картинки, какие-то реже.

Как же быть с верхним концом струйки? Он должен «высыхать», причём со своей скоростью. Не будем придумывать ничего сложного. Пусть верхний конец тоже будет каплей, но чёрного цвета. Такая «капля» при перемещении будет не добавлять цифры, а наоборот стирать их. Получается прямо какая-то антикапля, антиматерия — красиво и стильно.

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

Создаём капли

Итак, все действия с каплями и антикаплями мы будем выполнять в методах класса. Назовём его Drop и напишем метод создания объекта класса:

def __init__ (self):
    self.x = random.randint (0, width) # Начальное положение по горизонтали
    self.y = -1 # Начальное положение по вертикали - за верхней границей экрана
    self.drop_type = random.randint (0, 1) # Тип: антикапля или капля
    self.timeout = random.randint (0, 3) # Задержка до следующего перемещения
    self.wait_count = random.randint (0, 3) # Счетчик паузы

С атрибутами x и y всё понятно. Второй равен -1, чтобы капля раньше времени не показывалась на экране. Атрибуты timeout и wait_count нужны для обеспечения разной скорости падения капель. Первый задаёт постоянную скорость стекания, второй — итерационный счётчик.

Перемещаем капли

Теперь напишем метод перемещения капли с учётом её скорости.

def move (self):
    if drop.wait_count < drop.timeout: # Пока рано перемещать
        drop.wait_count += 1 # Увеличиваем счётчик паузы
        return False
    else: # Уже можно перемещать
        drop.wait_count = 0 # Сбрасываем счётчик паузы
        drop.y += 1 # Перемещаем каплю или антикаплю на шаг вниз
        return True

Метод возвращает логическое значение — факт перемещения капли. Или антикапли — всё равно.

Рисуем струйку

С перемещением разобрались. Настало время рисовать.

def draw (self):
    if self.drop_type == 1:
        symbol = str (random.randint (1, 9))
        con_print (self.
  x, self.y, green, symbol)
        self.zero_draw () # Рисуем яркий ноль
    else:
        con_print (self.x, self.y, green, ' ')

Здесь мы вызываем два новых ещё не написанных метода: con_print и zero_draw. Первый будет выводить символ нужного цвета в указанное место консольного окна. Второй будет рисовать дополнительный яркий ноль в начале струйки.

Вот, собственно, и второй метод:

def zero_draw (self):
    if (self.y < height):
    con_print (self.x, self.y+1, lgreen, '0')

Организуем перерождение капель

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

def renew (self):
    self.__init__ ()

Теперь у нас есть всё, что нужно. Класс Drop готов.

Выводим текст в консоль

Вырвемся за границы класса Drop и напишем две функции для вывода текста в консольное окно.

Если мы попытаемся напечатать что-то в нижнем правом углу консольного окна, то снизу автоматически добавится ещё одна строка. Ничего не поделаешь: в этом месте в нашей идеальной «Матрице» будет «битый пиксель»:

def is_rb_corner (x, y):
    if x==width and y==height:
        return True
    else:
        return False

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

def con_print (x, y, color, symbol):
    if not is_rb_corner (x, y):
        bext.goto (x, y)
        sys.stdout.write (color)
        print (symbol, end='')

Собираем всё воедино

Все компоненты нашей будущей «Матрицы» готовы. Теперь осталось всё собрать вместе и запустить.

Создадим массив капель и антикапель (какого типа родится объект — дело случая).

drops = []
for i in range (1, width*2//3):
    drop = Drop ()
    drops.append (drop)

И, наконец, самый главный цикл:

while True:
    for drop in drops:
        if drop. move (): # Проверяем перемещение элемента
            drop.draw () # Отображаем элемент
            if drop.y >= height: # Достигли дна
                drop.renew () # Обновляем элемент
    key = bext.getKey (blocking = False) # Проверяем, нажата ли клавиша
    if key == 'esc': # Если нажата ESC, то выходим из программы
        bext.clear ()
        sys.exit ()
    time.sleep (0.02) # Задержка

Вся программа целиком

import sys
import random
import time

# Подключаем дополнительные модули
try:
    import bext, colorama
except ImportError:
    print ('Для запуска программы нужны модули bext и colorama.')
    sys.exit ()

class Drop:
    def __init__ (self):
        self.x = random.randint (0, width) # Начальное положение по горизонтали
        self.y = -1 # Начальное положение по вертикали - за верхней границей экрана
        self.drop_type = random.randint (0, 1) # Тип: антикапля или капля
        self. timeout = random.randint (0, 3) # Задержка до следующего перемещения
        self.wait_count = random.randint (0, 3) # Счетчик паузы
    def renew (self):
        self.__init__ ()
    def move (self):
        if drop.wait_count < drop.timeout: # Пока рано перемещать
            drop.wait_count += 1 # Увеличиваем счётчик паузы
            return False
        else: # Уже можно перемещать
            drop.wait_count = 0 # Сбрасываем счётчик паузы
            drop.y += 1 # Перемещаем каплю или антикаплю на шаг вниз
            return True
    def draw (self):
        if self.drop_type == 1:
            symbol = str (random.randint (1, 9))
            con_print (self.x, self.y, green, symbol)
            self.zero_draw () # Рисуем яркий ноль
        else:
            con_print (self.x, self.y, green, ' ')
    def zero_draw (self):
        if (self.y < height):
            con_print (self. x, self.y+1, lgreen, '0')

def is_rb_corner (x, y):
    if x==width and y==height:
        return True
    else:
        return False

def con_print (x, y, color, symbol):
    if not is_rb_corner (x, y):
        bext.goto (x, y)
        sys.stdout.write (color)
        print (symbol, end='')

bext.title ('Matrix') # Меняем заголовок консольного окна
bext.clear () # Очищаем консольное окно
bext.hide () # Скрываем курсор в консольном окне
width, height = bext.size () # Получаем размер консольного окна
width -= 1
height -= 1

green = colorama.Fore.GREEN
lgreen = colorama.Fore.LIGHTGREEN_EX

# Создаём массив капель и антикапель
drops = []
for i in range (1, width*2//3):
    drop = Drop ()
    drops.append (drop)

while True:
    for drop in drops:
        if drop.move (): # Проверяем перемещение элемента
            drop.draw () # Отображаем элемент
            if drop. y >= height: # Достигли дна
                drop.renew () # Обновляем элемент
    key = bext.getKey (blocking = False) # Проверяем, нажата ли клавиша
    if key == 'esc': # Если нажата ESC, то выходим из программы
        bext.clear ()
        sys.exit ()
    time.sleep (0.02) # Задержка

Предлагаю вам поэкспериментировать с этой программой. Попробуйте добавить к «Матрице» свои дополнительные необычные эффекты. Интересно, что у вас получится.

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

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

NumPy — это библиотека Python, предназначенная для эффективной работы с массивами в Python. Он быстрый, простой в освоении и эффективный в хранении. В NumPy мы можем создать n-мерный массив.

Что такое векторы?

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

Мы используем метод np.array() для создания вектора.

Синтаксис

 np.array(список)
 

Параметры

Возвращаемое значение − возвращает вектор (numpy.ndarray)

Создание горизонтального вектора из заданного списка

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

Алгоритм (шаги)

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

• Используйте ключевое слово import для импорта модуля NumPy с псевдонимом.

• Создайте переменную для хранения Горизонтального Одномерного списка.

• Используйте функцию numpy.array() (возвращает ndarray. ndarray — это объект массива, который удовлетворяет заданным требованиям) для создания vector_1 путем передачи заданного list_1 в качестве аргумента, т. е. вектора в виде строки .

• Распечатайте результирующий горизонтальный вектор.

Следующая программа создает горизонтальный вектор из списка с помощью функции массива () NumPy и возвращает его —

Пример

 
 # импорт модуля numpy с псевдонимом
импортировать numpy как np
 
# создание горизонтального одномерного списка
list_1 = [15, 20, 25, 'Привет', 'TutorialsPoint']
 
# создание вектора (массива numpy) горизонтального списка
# Это горизонтальный вектор
vector_1 = np.массив (список_1)
print('Данный список =',list_1)
# печать результирующего горизонтального вектора
print("Результирующий горизонтальный вектор:")
печать (вектор_1) 
 

Вывод

При выполнении вышеуказанная программа будет генерировать следующий вывод —

 Данный список = [15, 20, 25, «Привет», «TutorialsPoint»]
Результирующий горизонтальный вектор:
['15' '20' '25' 'Привет' 'TutorialsPoint']
 

Создание вертикального вектора

В этом методе мы создаем вертикальный вектор с помощью функции numpy. array().

Алгоритм (шаги)

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

• Используйте ключевое слово import для импорта модуля NumPy с псевдонимом.

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

• Распечатайте результирующий вертикальный вектор.

Пример

Следующая программа создает вертикальный вектор с помощью функции NumPy array() и возвращает его —

 
 # импорт модуля NumPy с псевдонимом
импортировать numpy как np
# Передача вертикального списка в качестве аргумента функции array()
# создание вертикального вектора (массива NumPy) второго списка
vector_2 = np.array([[5], [40], [20], ['Привет'], ['TutorialsPoint']])
 
# печать результирующего вертикального вектора
print("Результирующий вертикальный вектор:")
print (vector_2) 
 

Вывод

При выполнении вышеуказанная программа сгенерирует следующий вывод —

 Результирующий вертикальный вектор:
[['5']
 ['40']
 ['20']
 ['Привет']
 ['ТуториалсПойнт']]
 

Создание матрицы с использованием функции numpy.

mat()

В этом методе мы создаем матрицу, используя функцию numpy.mat() .

В Python метод mat() используется для преобразования массива в матрицу.

Параметры

Функция mat() принимает следующие аргументы —

Возвращаемое значение

Метод mat() интерпретирует ввод как матрицу и возвращает ее.

Алгоритм (шаги)

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

• Используйте ключевое слово import для импорта модуля NumPy с псевдонимом.

• Передать вложенный список (список списков) в качестве аргумента функции numpy.mat() (метод mat() используется для преобразования массива в матрицу) и сохранить эту матрицу в переменной.

• Распечатайте полученную матрицу.

Пример

Следующая программа создает матрицу с помощью функции Numpy mat () и возвращает ее —

 
 # импорт модуля numpy с псевдонимом
импортировать numpy как np
# Создание матрицы с помощью функции numpy. mat()
inputMatrix = np.mat([[1, 2, 3],
   [4, 5, 6],
   [7, 8, 9]])
print("Созданная матрица:")
print (inputMatrix) 
 

Вывод

При выполнении вышеуказанная программа сгенерирует следующий вывод —

 Созданная матрица:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
 

Создание матрицы с использованием функции numpy.matrix()

В этом методе мы создаем матрицу, используя numpy.matrix() функция.

Параметры

Функция numpy.matrix() принимает следующие аргументы —

Возвращаемое значение:

Матричное представление данных

Алгоритм (шаги)

Ниже приведены алгоритм/шаги выполнить желаемая задача —

• Используйте ключевое слово import для импорта модуля NumPy с псевдонимом.

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

• Распечатайте полученную матрицу.

Пример

Следующая программа создает матрицу с помощью функции Numpy matrix () и возвращает ее —

 
 # импорт модуля numpy с псевдонимом
импортировать numpy как np
 
# Создание матрицы с помощью функции numpy.matrix()
inputMatrix = np.matrix([[5, 3, 9, 11],
   [4, 5, 6, 23],
   [7, 8, 9, 84]])
 
print("Созданная матрица:")
print (inputMatrix) 
 

Вывод

При выполнении вышеуказанная программа сгенерирует следующий вывод —

 Созданная матрица:
[[ 5 3 9 11]
 [ 4 5 6 23 ]
 [ 7 8 9 84]]
 

Заключение

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

Матрица в NumPy | Узнайте, как создать матрицу в NumPy?

Matrix — это подкласс класса ndarray в библиотеке Python Numpy. Он в основном используется для преобразования строки или объекта, подобного массиву, в 2D-матрицу. Возвращаемая таким образом матрица представляет собой специализированный двумерный массив. Что касается синтаксиса, матричная функция записывается следующим образом:

Синтаксис:

 numpy.matrix(data, dtype, copy) 

Важные параметры:

• Данные: Данные должны быть в форма массива, как объект или строка, разделенная запятыми
• Dtype: Тип данных возвращаемой матрицы
• Копия: Этот флаг похож на объект. Он определяет, являются ли данные уже массивом. Флаг определяет, копируются ли данные или создается новое представление.

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

Мы можем создать матрицу в Numpy, используя такие функции, как array(), ndarray() или matrix(). Матричная функция по умолчанию создает специализированный 2D-массив из заданного ввода. Входные данные должны быть в виде строки или массива, подобного объекту. Давайте продемонстрируем создание матрицы, используя функцию matrix() со строкой в ​​качестве типа ввода.

Код:

 импортировать numpy как np
#создание матрицы из строки
A = np.matrix('1 2 3; 4 5 6')
print("Массив, созданный с использованием строки:\n", A) 

Вывод:

Теперь давайте продемонстрируем создание матрицы с использованием matrix() с объектом, подобным массиву, в качестве типа ввода.

Код:

 импортировать numpy как np
#создание матрицы из массива, подобного объекту
B = np.matrix([[1, 2, 3], [4, 5, 6]])
print("Массив, созданный с использованием массива, подобного объекту:\n", B) 

Вывод:

Матричные функции в NumPy с примерами

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

Функция	Описание
матрица.T	Возвращает транспонирование входной матрицы
матрица. H	Возвращает комплексно-сопряженное транспонирование входной матрицы
матрица.I	Возвращает мультипликативную обратную матрицу
матрица.A	Вернуть входную матрицу как объект ndarray.
матрица.все()	Проверяет, все ли матричные элементы вдоль заданной оси оцениваются как True. Это похоже на функцию ndarray.all().
матрица.любой()	Проверяет, имеет ли какой-либо из элементов матрицы вдоль заданной оси значение True.
матрица.argmax()	Возвращает индексы максимальных значений по оси во входной матрице
матрица.argmin()	Возвращает индексы минимальных значений по оси во входной матрице
matrix.argsort()	Возвращает индексы, по которым сортируется матрица
матрица.astype()	Возвращает копию входной матрицы после изменения типа
матрица. выбрать()	Возвращает новую матрицу с выбранными индексами из входной матрицы
матрица.клип()	Возвращает новую матрицу в выбранных пределах из входной матрицы
матрица.сжатие()	Возвращает выбранный срез матрицы по заданной оси
матрица.conj()	Возвращает комплексное сопряжение заданной матрицы
матрица.cumprod()	Возвращает совокупное произведение элементов заданной матрицы по заданной оси
матрица.cumsum()	Возвращает совокупную сумму элементов в заданной матрице вместе с заданной осью
матрица.диагональ()	Возвращает диагональные элементы матрицы
матрица.точка()	Возвращает скалярное произведение двух матриц

Несколько примеров для иллюстрации матричных функций

Пример №1. Программа для поиска транспонированной и мультипликативной инверсии заданной матрицы

Код:

 import numpy as np
A = np. matrix('1 2 3; 4 5 6')
print("Матрица:\n", А)
# Транспонировать матрицу
print("Транспонирование матрицы A:\n", A.getT())
# Комплексно-сопряженное транспонирование
print("Комплексное транспонирование матрицы A:\n", A.getH())
# Мультипликативное обратное
print("Мультипликативная обратная матрица A:\n", A.getI()) 

Вывод:

Пример № 2. Программа для поиска максимального и минимального индексов в заданной матрице

Код:

 import numpy as np
A = np.matrix('1 2 3; 4 5 6')
print("Матрица:\n", А)
#максимальные индексы
print("Максимальные индексы в A :\n", A.argmax(0))
#минимальные индексы
print("Минимальные индексы в A :\n", A.argmin(0)) 

Вывод:

Пример №3. Программа для иллюстрации отсечения в заданной матрице

Код:

 импортировать numpy как np
A = np.matrix('1 2 3; 4 5 6')
print("Матрица:\n", А)
#матрица отсечения
print("Обрезанная матрица:\n", A. clip(1,4)) 

Вывод:

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

Пример №4. Программа для нахождения кумулятивной суммы и произведения заданной матрицы

Код:

 импортировать numpy как np
A = np.matrix('1 2 3; 4 5 6; 7,8,9')
print("Матрица:\n", А)
#совокупный продукт по оси = 0
print("Совокупное произведение элементов по оси 0: \n", A.cumprod(0))
#накопленная сумма по оси = 0
print("Накопленная сумма элементов по оси 0 равна: \n", A.cumsum(0)) 

Вывод:

Пример №5. Программа для нахождения скалярного произведения и диагональных значений заданной матрицы

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

Код:

 импортировать numpy как np
A = np. matrix('1 2 3; 4 5 6; 7,8,9')
print("Матрица:\n", А)
#диагональные значения
print("Диагональ матрицы A :\n", A.diagonal(0,0,1))
#скалярное произведение
print("Скалярное произведение матрицы A с 2 :\n", A.dot(2)) 

Вывод:

Преимущества Matrix в NumPy

• Одно из основных преимуществ использования матрицы NumPy заключается в том, что они занимают меньше места в памяти и обеспечивают лучшую скорость выполнения по сравнению с аналогичными структурами данных в python (списки и кортежи).
• Матрица NumPy поддерживает некоторые конкретные научные функции, такие как поэлементная кумулятивная сумма, кумулятивное произведение, сопряженное транспонирование, мультипликативное обратное и т. д. Списки или строки Python не поддерживают эти функции .

Заключение

Матрица NumPy — это специализированный двумерный массив, созданный из строки или объекта, подобного массиву. Это чрезвычайно полезно в научных и математических вычислениях.