Как создать матрицу в python: Изучаем матрицы в питоне и массивы NumPy в Python

Изучаем матрицы в питоне и массивы NumPy в Python

2022-12-19

Матрица — это двухмерная структура данных, в которой числа расположены в виде строк и столбцов. Например:

Эта матрица является матрицей три на четыре, потому что она состоит из 3 строк и 4 столбцов.

• Матрицы в Python
• NumPy массивы в Python
• Как создать массив NumPy?
  • Массив целых чисел, чисел с плавающей точкой и составных чисел
  • Массив нулей и единиц
  • Использование arange() и shape()
• Операции с матрицами
  • Сложение двух матриц или сумма элементов массива Python
  • Умножение двух матриц Python
  • Транспонирование матрицы питон
• Доступ к элементам матрицы, строкам и столбца
  • Доступ к элементам матрицы
  • Доступ к строкам матрицы
  • Доступ к столбцам матрицы
• Разделение матрицы

Python не имеет встроенного типа данных для матриц. Но можно рассматривать список как матрицу. Например:

A = [[1, 4, 5], 
    [-5, 8, 9]]

Этот список является матрицей на 2 строки и 3 столбца.

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

Давайте посмотрим, как работать с вложенным списком.

A = [[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]]
print("A =", A) 
print("A[1] =", A[1])      # вторая строка
print("A[1][2] =", A[1][2])   # третий элемент второй строки
print("A[0][-1] =", A[0][-1])   # последний элемент первой строки
column = [];        # пустой список
for row in A:
  column.append(row[2])   
print("3rd column =", column)

Когда мы запустим эту программу, результат будет следующий:

A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]
A [1] = [-5, 8, 9, 0]
A [1] [2] = 9
A [0] [- 1] = 12
3-й столбец = [5, 9, 11]

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

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

• Ознакомьтесь: Как установить NumPy Python?
• Если вы работаете в Windows, скачайте и установите дистрибутив anaconda Python. Он поставляется вместе с NumPy и другими расширениями.

После установки NumPy можно импортировать и использовать его.

NumPy предоставляет собой многомерный массив чисел (который на самом деле является объектом). Давайте рассмотрим приведенный ниже пример:

import numpy as np
a = np.array([1, 2, 3])
print(a)               # Вывод: [1, 2, 3]
print(type(a))         # Вывод: <class 'numpy.ndarray'>

Как видите, класс массива NumPy называется ndarray.

Существует несколько способов создания массивов NumPy.

import numpy as np
A = np.array([[1, 2, 3], [3, 4, 5]])
print(A)
A = np.array([[1.1, 2, 3], [3, 4, 5]]) # Массив чисел с плавающей запятой
print(A)
A = np. array([[1, 2, 3], [3, 4, 5]], dtype = complex) # Массив составных чисел
print(A)

Когда вы запустите эту программу, результат будет следующий:

[[1 2 3]
 [3 4 5]]
[[1.1 2. 3.]
 [3. 4. 5.]]
[[1. + 0.j 2. + 0.j 3. + 0.j]
 [3. + 0.j 4. + 0.j 5. + 0.j]]

import numpy as np
zeors_array = np.zeros( (2, 3) )
print(zeors_array)
'''
 Вывод:
 [[0. 0. 0.]
  [0. 0. 0.]]
'''
ones_array = np.ones( (1, 5), dtype=np.int32 ) // указание dtype
print(ones_array)      # Вывод: [[1 1 1 1 1]]

Здесь мы указали dtype — 32 бита (4 байта). Следовательно, этот массив может принимать значения от -2^-31 до 2^-31-1.

import numpy as np
A = np.arange(4)
print('A =', A)
B = np.arange(12).reshape(2, 6)
print('B =', B)
''' 
Вывод:
A = [0 1 2 3]
B = [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
'''

Узнайте больше о других способах создания массива NumPy .

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

Рассмотрим, как выполнить ту же задачу, используя массив NumPy.

Мы используем оператор +, чтобы сложить соответствующие элементы двух матриц NumPy.

import numpy as np
A = np.array([[2, 4], [5, -6]])
B = np.array([[9, -3], [3, 6]])
C = A + B      # сложение соответствующих элементов
print(C)
''' 
Вывод:
[[11  1]
 [ 8  0]]
 '''

Чтобы умножить две матрицы, мы используем метод dot(). Узнайте больше о том, как работает numpy.dot .

Примечание: * используется для умножения массива (умножения соответствующих элементов двух массивов), а не умножения матрицы.

import numpy as np
A = np.array([[3, 6, 7], [5, -3, 0]])
B = np.array([[1, 1], [2, 1], [3, -3]])
C = a.dot(B)
print(C)
''' 
Вывод:
[[ 36 -12]
 [ -1   2]]
'''

Мы используем numpy.transpose для вычисления транспонирования матрицы.

import numpy as np
A = np.array([[1, 1], [2, 1], [3, -3]])
print(A.transpose())
''' 
Вывод:
[[ 1  2  3]
 [ 1  1 -3]]
'''

Как видите, NumPy значительно упростил нашу задачу.

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

import numpy as np
A = np.array([2, 4, 6, 8, 10])
print("A[0] =", A[0])     # Первый элемент     
print("A[2] =", A[2])     # Третий элемент     
print("A[-1] =", A[-1])   # Последний элемент     

Когда вы запустите эту программу, результат будет следующий:

A [0] = 2
A [2] = 6
A [-1] = 10

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

import numpy as np
A = np.array([[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
#  Первый элемент первой строки
print("A[0][0] =", A[0][0])  
# Третий элемент второй строки
print("A[1][2] =", A[1][2])
# Последний элемент последней строки
print("A[-1][-1] =", A[-1][-1])     

Когда мы запустим эту программу, результат будет следующий:

A [0] [0] = 1
A [1] [2] = 9
A [-1] [- 1] = 19

import numpy as np
A = np. array([[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[0] =", A[0]) # Первая строка
print("A[2] =", A[2]) # Третья строка
print("A[-1] =", A[-1]) # Последняя строка (третья строка в данном случае)

Когда мы запустим эту программу, результат будет следующий:

A [0] = [1, 4, 5, 12]
A [2] = [-6, 7, 11, 19]
A [-1] = [-6, 7, 11, 19]

import numpy as np
A = np.array([[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[:,0] =",A[:,0]) # Первый столбец
print("A[:,3] =", A[:,3]) # Четвертый столбец
print("A[:,-1] =", A[:,-1]) # Последний столбец (четвертый столбец в данном случае)

Когда мы запустим эту программу, результат будет следующий:

A [:, 0] = [1 -5 -6]
A [:, 3] = [12 0 19]
A [:, - 1] = [12 0 19]

Если вы не знаете, как работает приведенный выше код, прочтите раздел «Разделение матрицы».

Разделение одномерного массива NumPy аналогично разделению списка. Рассмотрим пример:

import numpy as np
letters = np. array([1, 3, 5, 7, 9, 7, 5])
# с 3-го по 5-ый элементы
print(letters[2:5])        # Вывод: [5, 7, 9]
# с 1-го по 4-ый элементы
print(letters[:-5])        # Вывод: [1, 3]   
# с 6-го до последнего элемента
print(letters[5:])         # Вывод:[7, 5]
# с 1-го до последнего элемента
print(letters[:])          # Вывод:[1, 3, 5, 7, 9, 7, 5]
# список в обратном порядке
print(letters[::-1])          # Вывод:[5, 7, 9, 7, 5, 3, 1]

Теперь посмотрим, как разделить матрицу.

import numpy as np
A = np.array([[1, 4, 5, 12, 14], 
    [-5, 8, 9, 0, 17],
    [-6, 7, 11, 19, 21]])
print(A[:2, :4])  # две строки, четыре столбца
''' Вывод:
[[ 1  4  5 12]
 [-5  8  9  0]]
'''
print(A[:1,])  # первая строка, все столбцы
''' Вывод:
[[ 1  4  5 12 14]]
'''
print(A[:,2])  # все строки, второй столбец
''' Вывод:
[ 5  9 11]
'''
print(A[:, 2:5])  # все строки, с третьего по пятый столбец
''' Вывод:
[[ 5 12 14]
 [ 9  0 17]
 [11 19 21]]
'''

Использование NumPy вместо вложенных списков значительно упрощает работу с матрицами. Мы рекомендуем детально изучить пакет NumPy, если вы планируете использовать Python для анализа данных.

Вадим Дворниковавтор-переводчик статьи «Python Matrices and NumPy Arrays»

Изучаем матрицы в питоне и массивы NumPy в Python

2022-12-19

Матрица — это двухмерная структура данных, в которой числа расположены в виде строк и столбцов. Например:

Эта матрица является матрицей три на четыре, потому что она состоит из 3 строк и 4 столбцов.

• Матрицы в Python
• NumPy массивы в Python
• Как создать массив NumPy?
  • Массив целых чисел, чисел с плавающей точкой и составных чисел
  • Массив нулей и единиц
  • Использование arange() и shape()
• Операции с матрицами
  • Сложение двух матриц или сумма элементов массива Python
  • Умножение двух матриц Python
  • Транспонирование матрицы питон
• Доступ к элементам матрицы, строкам и столбца
  • Доступ к элементам матрицы
  • Доступ к строкам матрицы
  • Доступ к столбцам матрицы
• Разделение матрицы

Python не имеет встроенного типа данных для матриц. Но можно рассматривать список как матрицу. Например:

A = [[1, 4, 5], 
    [-5, 8, 9]]

Этот список является матрицей на 2 строки и 3 столбца.

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

Давайте посмотрим, как работать с вложенным списком.

A = [[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]]
print("A =", A) 
print("A[1] =", A[1])      # вторая строка
print("A[1][2] =", A[1][2])   # третий элемент второй строки
print("A[0][-1] =", A[0][-1])   # последний элемент первой строки
column = [];        # пустой список
for row in A:
  column.append(row[2])   
print("3rd column =", column)

Когда мы запустим эту программу, результат будет следующий:

A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]
A [1] = [-5, 8, 9, 0]
A [1] [2] = 9
A [0] [- 1] = 12
3-й столбец = [5, 9, 11]

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

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

• Ознакомьтесь: Как установить NumPy Python?
• Если вы работаете в Windows, скачайте и установите дистрибутив anaconda Python. Он поставляется вместе с NumPy и другими расширениями.

После установки NumPy можно импортировать и использовать его.

NumPy предоставляет собой многомерный массив чисел (который на самом деле является объектом). Давайте рассмотрим приведенный ниже пример:

import numpy as np
a = np.array([1, 2, 3])
print(a)               # Вывод: [1, 2, 3]
print(type(a))         # Вывод: <class 'numpy.ndarray'>

Как видите, класс массива NumPy называется ndarray.

Существует несколько способов создания массивов NumPy.

import numpy as np
A = np.array([[1, 2, 3], [3, 4, 5]])
print(A)
A = np.array([[1.1, 2, 3], [3, 4, 5]]) # Массив чисел с плавающей запятой
print(A)
A = np. array([[1, 2, 3], [3, 4, 5]], dtype = complex) # Массив составных чисел
print(A)

Когда вы запустите эту программу, результат будет следующий:

[[1 2 3]
 [3 4 5]]
[[1.1 2. 3.]
 [3. 4. 5.]]
[[1. + 0.j 2. + 0.j 3. + 0.j]
 [3. + 0.j 4. + 0.j 5. + 0.j]]

import numpy as np
zeors_array = np.zeros( (2, 3) )
print(zeors_array)
'''
 Вывод:
 [[0. 0. 0.]
  [0. 0. 0.]]
'''
ones_array = np.ones( (1, 5), dtype=np.int32 ) // указание dtype
print(ones_array)      # Вывод: [[1 1 1 1 1]]

Здесь мы указали dtype — 32 бита (4 байта). Следовательно, этот массив может принимать значения от -2^-31 до 2^-31-1.

import numpy as np
A = np.arange(4)
print('A =', A)
B = np.arange(12).reshape(2, 6)
print('B =', B)
''' 
Вывод:
A = [0 1 2 3]
B = [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
'''

Узнайте больше о других способах создания массива NumPy .

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

Мы используем оператор +, чтобы сложить соответствующие элементы двух матриц NumPy.

import numpy as np
A = np.array([[2, 4], [5, -6]])
B = np.array([[9, -3], [3, 6]])
C = A + B      # сложение соответствующих элементов
print(C)
''' 
Вывод:
[[11  1]
 [ 8  0]]
 '''

Чтобы умножить две матрицы, мы используем метод dot(). Узнайте больше о том, как работает numpy.dot .

Примечание: * используется для умножения массива (умножения соответствующих элементов двух массивов), а не умножения матрицы.

import numpy as np
A = np.array([[3, 6, 7], [5, -3, 0]])
B = np.array([[1, 1], [2, 1], [3, -3]])
C = a.dot(B)
print(C)
''' 
Вывод:
[[ 36 -12]
 [ -1   2]]
'''

Мы используем numpy.transpose для вычисления транспонирования матрицы.

import numpy as np
A = np.array([[1, 1], [2, 1], [3, -3]])
print(A.transpose())
''' 
Вывод:
[[ 1  2  3]
 [ 1  1 -3]]
'''

Как видите, NumPy значительно упростил нашу задачу.

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

import numpy as np
A = np.array([2, 4, 6, 8, 10])
print("A[0] =", A[0])     # Первый элемент     
print("A[2] =", A[2])     # Третий элемент     
print("A[-1] =", A[-1])   # Последний элемент     

Когда вы запустите эту программу, результат будет следующий:

A [0] = 2
A [2] = 6
A [-1] = 10

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

import numpy as np
A = np.array([[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
#  Первый элемент первой строки
print("A[0][0] =", A[0][0])  
# Третий элемент второй строки
print("A[1][2] =", A[1][2])
# Последний элемент последней строки
print("A[-1][-1] =", A[-1][-1])     

Когда мы запустим эту программу, результат будет следующий:

A [0] [0] = 1
A [1] [2] = 9
A [-1] [- 1] = 19

import numpy as np
A = np. array([[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[0] =", A[0]) # Первая строка
print("A[2] =", A[2]) # Третья строка
print("A[-1] =", A[-1]) # Последняя строка (третья строка в данном случае)

Когда мы запустим эту программу, результат будет следующий:

A [0] = [1, 4, 5, 12]
A [2] = [-6, 7, 11, 19]
A [-1] = [-6, 7, 11, 19]

import numpy as np
A = np.array([[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[:,0] =",A[:,0]) # Первый столбец
print("A[:,3] =", A[:,3]) # Четвертый столбец
print("A[:,-1] =", A[:,-1]) # Последний столбец (четвертый столбец в данном случае)

Когда мы запустим эту программу, результат будет следующий:

A [:, 0] = [1 -5 -6]
A [:, 3] = [12 0 19]
A [:, - 1] = [12 0 19]

Если вы не знаете, как работает приведенный выше код, прочтите раздел «Разделение матрицы».

Разделение одномерного массива NumPy аналогично разделению списка. Рассмотрим пример:

import numpy as np
letters = np. array([1, 3, 5, 7, 9, 7, 5])
# с 3-го по 5-ый элементы
print(letters[2:5])        # Вывод: [5, 7, 9]
# с 1-го по 4-ый элементы
print(letters[:-5])        # Вывод: [1, 3]   
# с 6-го до последнего элемента
print(letters[5:])         # Вывод:[7, 5]
# с 1-го до последнего элемента
print(letters[:])          # Вывод:[1, 3, 5, 7, 9, 7, 5]
# список в обратном порядке
print(letters[::-1])          # Вывод:[5, 7, 9, 7, 5, 3, 1]

Теперь посмотрим, как разделить матрицу.

import numpy as np
A = np.array([[1, 4, 5, 12, 14], 
    [-5, 8, 9, 0, 17],
    [-6, 7, 11, 19, 21]])
print(A[:2, :4])  # две строки, четыре столбца
''' Вывод:
[[ 1  4  5 12]
 [-5  8  9  0]]
'''
print(A[:1,])  # первая строка, все столбцы
''' Вывод:
[[ 1  4  5 12 14]]
'''
print(A[:,2])  # все строки, второй столбец
''' Вывод:
[ 5  9 11]
'''
print(A[:, 2:5])  # все строки, с третьего по пятый столбец
''' Вывод:
[[ 5 12 14]
 [ 9  0 17]
 [11 19 21]]
'''

Использование NumPy вместо вложенных списков значительно упрощает работу с матрицами. Мы рекомендуем детально изучить пакет NumPy, если вы планируете использовать Python для анализа данных.

Вадим Дворниковавтор-переводчик статьи «Python Matrices and NumPy Arrays»

Матрица Python и введение в NumPy

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

Матрица — это двумерная структура данных, в которой числа расположены в строках и столбцах. Например:

Эта матрица представляет собой матрицу 3×4 (произносится как «три на четыре»), поскольку она имеет 3 строки и 4 столбца.

---

Python Matrix

Python не имеет встроенного типа для матриц. Однако мы можем рассматривать список списка как матрицу. Например:

 А = [[1, 4, 5],
    [-5, 8, 9]]
 

Мы можем рассматривать этот список как матрицу, имеющую 2 строки и 3 столбца.

Обязательно изучите списки Python, прежде чем продолжить эту статью.

---

Давайте посмотрим, как работать с вложенным списком.

 А = [[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]]
печать("А=", А)
print("A[1] =", A[1]) # 2-я строка
print("A[1][2] =", A[1][2]) # 3-й элемент 2-й строки
print("A[0][-1] =", A[0][-1]) # Последний элемент 1-й строки
столбец = []; # пустой список
для строки в A:
  столбец.добавлять (строка [2])
print("3-й столбец =", столбец)
 

Когда мы запустим программу, вывод будет:

  А = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]
А[1] = [-5, 8, 9, 0]
А[1][2] = 9
А[0][-1] = 12
3-й столбец = [5, 9, 11]
  

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

• Добавить две матрицы
• Транспонировать матрицу
• Умножить две матрицы

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

---

NumPy Array

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

• Посетите: Как установить NumPy?
• Если вы используете Windows, загрузите и установите дистрибутив Python anaconda. Он поставляется с NumPy и несколькими другими пакетами, связанными с наукой о данных и машинным обучением.

После установки NumPy его можно импортировать и использовать.

---

NumPy предоставляет многомерный массив чисел (который на самом деле является объектом). Возьмем пример:

 импортировать numpy как np
а = np.массив ([1, 2, 3])
print(a) # Вывод: [1, 2, 3]
print(type(a)) # Вывод: 
 

Как видите, класс массива NumPy называется ndarray .

---

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

Существует несколько способов создания массивов NumPy.

---

1. Массив целых, вещественных и комплексных чисел

 импортировать numpy как np
A = np. массив ([[1, 2, 3], [3, 4, 5]])
печать(А)
A = np.array([[1.1, 2, 3], [3, 4, 5]]) # Массив чисел с плавающей запятой
печать(А)
A = np.array([[1, 2, 3], [3, 4, 5]], dtype = complex) # Массив комплексных чисел
печать(А)
 

Когда вы запустите программу, вывод будет:

  [[1 2 3]
 [3 4 5]]
[[1.1 2. 3. ]
 [3. 4. 5. ]]
[[1.+0.j 2.+0.j 3.+0.j]
 [3.+0.к 4.+0.к 5.+0.к]]
  

---

2. Массив нулей и единиц

 импортировать numpy как np
zeors_array = np.zeros ((2, 3))
печать (zeors_array)
'''
 Выход:
 [[0. 0. 0.]
  [0. 0. 0.]]
'''
one_array = np.ones( (1, 5), dtype=np.int32 ) // указание dtype
print(ones_array) # Вывод: [[1 1 1 1 1]]
 

Здесь мы указали dtype до 32 бит (4 байта). Следовательно, этот массив может принимать значения от -2 -31 до 2 -31 -1 .

---

3. Использование arange() и shape()

 импортировать numpy как np
A = np.arange(4)
печать('А =', А)
B = np. arange(12).reshape(2, 6)
печать('В =', В)
'''
Выход:
А = [0 1 2 3]
В = [[ 0 1 2 3 4 5]
 [ 6 7 8 9 10 11]]
'''
 

Узнайте больше о других способах создания массива NumPy.

---

Операции с матрицами

Выше мы привели 3 примера: сложение двух матриц, умножение двух матриц и транспонирование матрицы. Раньше мы использовали вложенные списки для написания этих программ. Давайте посмотрим, как мы можем выполнить ту же задачу, используя массив NumPy.

---

Добавление двух матриц

Мы используем оператор + для добавления соответствующих элементов двух матриц NumPy.

 импортировать numpy как np
A = np.массив ([[2, 4], [5, -6]])
B = np.массив([[9, -3], [3, 6]])
C = A + B # поэлементное сложение
печать(С)
'''
Выход:
[[11 1]
 [ 8 0]]
 ''' 

---

Умножение двух матриц

Чтобы умножить две матрицы, мы используем метод dot() . Узнайте больше о том, как работает numpy.dot.

Примечание: * используется для умножения массивов (умножения соответствующих элементов двух массивов), а не умножения матриц.

 импортировать numpy как np
A = np.массив ([[3, 6, 7], [5, -3, 0]])
B = np.массив ([[1, 1], [2, 1], [3, -3]])
С = А. точка (В)
печать(С)
'''
Выход:
[[ 36 -12]
 [-1 2]]
'''
 

---

Транспонирование матрицы

Мы используем numpy.transpose для вычисления транспонирования матрицы.

 импортировать numpy как np
A = np.массив ([[1, 1], [2, 1], [3, -3]])
печать (A.transpose())
'''
Выход:
[[ 1 2 3]
 [ 1 1 -3]]
'''
 

Как видите, NumPy значительно облегчил нашу задачу.

---

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

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

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

 импортировать numpy как np
А = np.массив ([2, 4, 6, 8, 10])
print("A[0] =", A[0]) # Первый элемент
print("A[2] =", A[2]) # Третий элемент
print("A[-1] =", A[-1]) # Последний элемент
 

Когда вы запустите программу, вывод будет:

  А[0] = 2
А[2] = 6
А[-1] = 10
  

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

 импортировать numpy как np
A = np.массив([[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
# Первый элемент первой строки
печать("А[0][0] =", А[0][0])
# Третий элемент второй строки
печать("А[1][2] =", А[1][2])
# Последний элемент последней строки
print("А[-1][-1] =", А[-1][-1])
 

Когда мы запустим программу, вывод будет:

  А[0][0] = 1
А[1][2] = 9
А[-1][-1] = 19
  

---

Доступ к строкам матрицы

 импорт numpy как np
A = np.массив([[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[0] =", A[0]) # Первая строка
print("A[2] =", A[2]) # Третья строка
print("A[-1] =", A[-1]) # Последняя строка (в данном случае 3-я строка) 

Когда мы запустим программу, вывод будет:

  А[0] = [1, 4, 5, 12]
А[2] = [-6, 7, 11, 19]
А[-1] = [-6, 7, 11, 19]
  

---

Доступ к столбцам матрицы

 импорт numpy как np
A = np.массив([[1, 4, 5, 12],
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]])
print("A[:,0] =",A[:,0]) # Первый столбец
print("A[:,3] =", A[:,3]) # Четвертый столбец
print("A[:,-1] =", A[:,-1]) # Последний столбец (в данном случае 4-й столбец)
 

Когда мы запустим программу, вывод будет:

  А[:,0] = [ 1 -5 -6]
А[:,3] = [12 0 19]
А[:,-1] = [12 0 19]
  

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

---

Нарезка матрицы

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

Возьмем пример:

 импортировать numpy как np
буквы = np.array([1, 3, 5, 7, 9, 7, 5])
# элементы с 3-го по 5-й
print(letters[2:5]) # Вывод: [5, 7, 9]
# элементы с 1-го по 4-й
print(letters[:-5]) # Вывод: [1, 3]
# от 6-го до последнего элемента
print(letters[5:]) # Вывод:[7, 5]
# от 1-го до последнего элемента
print(letters[:]) # Вывод:[1, 3, 5, 7, 9, 7, 5]
# обращение списка
print(letters[::-1]) # Вывод:[5, 7, 9, 7, 5, 3, 1]
 

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

 импортировать numpy как np
A = np.массив([[1, 4, 5, 12, 14],
    [-5, 8, 9, 0, 17],
    [-6, 7, 11, 19, 21]])
print(A[:2, :4]) # две строки, четыре столбца
''' Выход:
[[ 1 4 5 12]
 [-5 8 9 0]]
'''
print(A[:1,]) # первая строка, все столбцы
''' Выход:
[[ 1 4 5 12 14]]
'''
print(A[:,2]) # все строки, второй столбец
''' Выход:
[ 5 9 11 ]
'''
print(A[:, 2:5]) # все строки, с третьего по пятый столбец
'''Выход:
[[ 5 12 14]
 [ 9 0 17 ]
 [11 19 21]]
'''
 

---

Как видите, использование NumPy (вместо вложенных списков) значительно упрощает работу с матрицами, и мы даже не коснулись основ. Мы предлагаем вам подробно изучить пакет NumPy, особенно если вы пытаетесь использовать Python для обработки и анализа данных.

Ресурсы NumPy, которые могут оказаться полезными:

• Учебное пособие по NumPy
• Ссылка NumPy

Программа Python для умножения двух матриц

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

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

В Python мы можем реализовать матрицу как вложенный список (список внутри списка).

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

Например, X = [[1, 2], [4, 5], [3, 6]] будет представлять собой матрицу 3x2 .

Первую строку можно выбрать как X[0] . И элемент в первой строке, первом столбце можно выбрать как X[0][0] .

Умножение двух матриц X и Y определяется, только если количество столбцов в X равно количеству строк Y .

Если X является матрицей n x m , а Y является матрицей m x l , то XY определено и имеет размерность n x l (но 5 YX не определено). Вот несколько способов реализовать матричное умножение в Python.

Исходный код: Умножение матриц с использованием вложенного цикла

 # Программа для умножения двух матриц с использованием вложенных циклов
#матрица 3х3
Х = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]
#матрица 3х4
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]
# результат 3x4
результат = [[0,0,0,0],
         [0,0,0,0],
         [0,0,0,0]]
# перебираем строки X
для i в диапазоне (len (X)):
   # перебираем столбцы Y
   для j в диапазоне (len (Y [0])):
       # перебираем строки Y
       для k в диапазоне (len (Y)):
           результат[i][j] += X[i][k] * Y[k][j]
для r в результате:
   печать (р)
 

Выход

  [114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23] 
 

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

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

Для больших операций с матрицами мы рекомендуем оптимизированные программные пакеты, такие как NumPy, которые в несколько (порядка 1000) раз быстрее, чем приведенный выше код.

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

 # Программа для умножения двух матриц с использованием понимания списков
#матрица 3х3
Х = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]
#матрица 3х4
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]
# результат 3x4
результат = [[сумма(a*b для a,b в zip(X_row,Y_col)) для Y_col в zip(*Y)] для X_row в X]
для r в результате:
   печать (р)
 

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

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