Как красиво вывести матрицу в python

Один из простых способов – использование метода f-строк, который позволяет контролировать длину поля для каждого элемента матрицы. Для этого можно указать максимальную ширину каждого столбца и использовать его для выравнивания чисел. Например, для матрицы с элементами, содержащими до 3 знаков после запятой, можно задать ширину столбца 10 символов:

matrix = [[1.234, 5.678, 9.012], [13.456, 78.910, 11.121]]
for row in matrix:
print(f"{row[0]:10.3f} {row[1]:10.3f} {row[2]:10.3f}")

Для более сложных случаев, когда матрица содержит различные типы данных (например, числа и строки), можно воспользоваться методом str.format(), который позволяет более гибко управлять выравниванием. Например, можно использовать символы выравнивания – {:<10} для выравнивания по левому краю и {:>10} для выравнивания по правому краю.

matrix = [["Alice", 34], ["Bob", 45], ["Charlie", 23]]
for row in matrix:
print("{:<10} {:>10}".format(row[0], row[1]))

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

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

Использование библиотеки NumPy для удобного отображения матриц

import numpy as np
matrix = np.array([[1.234, 2.345, 3.456], [4.567, 5.678, 6.789], [7.890, 8.901, 9.012]])
print(matrix)

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

np.set_printoptions(precision=2)
print(matrix)

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

np.set_printoptions(threshold=10)
large_matrix = np.random.rand(20, 20)
print(large_matrix)

matrix = [[1.23456, 2.34567, 3.45678], [4.56789, 5.67891, 6.78912]]
for row in matrix:
print(f"{row[0]:.2f} {row[1]:.2f} {row[2]:.2f}")

import numpy as np
np.set_printoptions(precision=3)
matrix = np.array([[1.23456, 2.34567, 3.45678], [4.56789, 5.67891, 6.78912]])
print(matrix)

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

matrix = np.array([[1.23456, 2.34567], [3.45678, 4.56789]])
rounded_matrix = np.around(matrix, decimals=2)
print(rounded_matrix)

Для наглядности, ниже представлена матрица с разными вариантами округления и точности:

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

matrix = [[1.23456, 2.34567, 3.45678], [4.56789, 5.67891, 6.78912]]
for row in matrix:
for element in row:
print(f"{element:.2f}", end=" ")  # Округление до двух знаков после запятой

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

matrix = [[1.23456, 'Hello'], [4.56789, 'World']]
for row in matrix:
for element in row:
if isinstance(element, float):
print(f"{element:.2f}", end=" ")  # Форматирование чисел
else:
print(f"{element:<10}", end=" ")  # Форматирование строк
print()

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

Как задать цветовое оформление для элементов матрицы

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

Для начала необходимо установить colorama с помощью pip:

pip install colorama

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

from colorama import Fore, Back, Style, init
init(autoreset=True)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
for element in row:
if element % 2 == 0:
print(Fore.GREEN + str(element), end=" ")  # Зеленый для четных чисел
else:
print(Fore.RED + str(element), end=" ")  # Красный для нечетных чисел
print()

Также можно использовать termcolor, чтобы добавить дополнительные стили, такие как подчеркивание или жирный шрифт. Для начала необходимо установить библиотеку:

pip install termcolor

Пример использования termcolor для выделения элементов:

from termcolor import colored
matrix = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
for row in matrix:
for element in row:
if element > 50:
print(colored(str(element), 'blue', attrs=['bold']), end=" ")  # Синие и жирные элементы больше 50
else:
print(colored(str(element), 'yellow'), end=" ")  # Желтые элементы меньше или равные 50
print()

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

• colored(str(element), 'color', attrs=['bold']) – Применение жирного шрифта.
• colored(str(element), 'color', attrs=['underline']) – Подчеркивание текста.
• colored(str(element), 'color') – Простое изменение цвета.

matrix = [[1.23456, 2.34567, 3.45678], [4.56789, 5.67891, 6.78912]]
for row in matrix:
print(f"{row[0]:.2f} {row[1]:.2f} {row[2]:.2f}")

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

for row in matrix:
print(f"{row[0]:>10.2f} {row[1]:>10.2f} {row[2]:>10.2f}")

В этом случае :>10.2f означает, что все элементы будут выровнены по правому краю, а общая ширина для каждого числа составит 10 символов.

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

matrix = [["Alice", 34], ["Bob", 45], ["Charlie", 23]]
for row in matrix:
print(f"{row[0]:<10} {row[1]:>10}")

В этом примере {row[0]:<10} выравнивает строковые данные по левому краю, а {row[1]:>10} – числовые по правому краю, задавая для чисел ширину поля 10 символов.

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

def format_matrix(matrix):
column_widths = [max(len(str(item)) for item in col) for col in zip(*matrix)]
for row in matrix:
print("  ".join(f"{str(item):<{column_widths[i]}}" for i, item in enumerate(row)))
matrix = [["Alice", 34], ["Bob", 45], ["Charlie", 23]]
format_matrix(matrix)

В этом коде функция format_matrix() вычисляет ширину столбцов и применяет её для выравнивания элементов. Это особенно удобно, когда данные матрицы имеют переменную длину строк.

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

def pretty_print(matrix, precision=2, width=10):
# Вычисляем максимальную ширину для каждого столбца
column_widths = [max(len(f"{item:.{precision}f}") if isinstance(item, (int, float)) else len(str(item))
for item in col) for col in zip(*matrix)]
for row in matrix:
for i, item in enumerate(row):
# Форматируем элементы с заданной точностью и шириной
if isinstance(item, (int, float)):
print(f"{item:.{precision}f}".rjust(column_widths[i]), end="  ")
else:
print(f"{str(item):<{column_widths[i]}}", end="  ")
# Пример использования функции
matrix = [["Alice", 34], ["Bob", 45], ["Charlie", 23]]
pretty_print(matrix)

В этой функции:

• precision задает точность для числовых значений. По умолчанию установлено 2 знака после запятой, но это можно изменить при вызове функции.
• width управляет минимальной шириной столбца, но ширина столбца динамически изменяется в зависимости от максимальной длины элемента в этом столбце.
• Каждый элемент форматируется с учетом его типа данных – для чисел применяется точность и выравнивание, для строк – выравнивание по левому краю.

Вопрос-ответ: