Как транспонировать list python

Как из списка списков получить такой результат?

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

lst = [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']] result = [list(x) for x in zip(*lst)]

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

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

for row in result: print(' '.join(row))

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

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

Как вариант

list_of_lists = [['1', '2', '3'],['4', '5', '6'],['7', '8', '9']] # обход элементов каждого вложенного списка и сохранение их в новый список new_list = [] for i in range(len(list_of_lists[0])): for lst in list_of_lists: new_list.append(lst[i]) # транспонирование списка списков transposed_list = list(zip(*list_of_lists)) # преобразование каждого кортежа в строку и объединение элементов с помощью пробела result = '\n'.join([' '.join(t) for t in transposed_list]) print(result)

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

lst = [['1', '2', '3'],['4', '5', '6'],['7', '8', '9']] new_lst = [] for i in range(len(lst[0])): temp = [] for j in range(len(lst)): temp.append(lst[j][i]) new_lst.append(temp) for row in new_lst: print(' '.join(row))

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

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

Вот мой вариант:

lst = [['1', '2', '3'],['4', '5', '6'],['7', '8', '9']] for i in range(len(lst)): for j in range(i): lst[i][j], lst[j][i] = lst[j][i], lst[i][j] for row in lst: print(*row)

Ответ написан более года назад
Комментировать
Нравится Комментировать
print(list[1][1])
Ответ написан более года назад
Комментировать
Нравится Комментировать
Ваш ответ на вопрос

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

• Python
• +3 ещё

Как наладить отправку сообщений от бота каждый день на aiogram?

• 1 подписчик
• час назад
• 21 просмотр

Transpose list of lists

There are two things we need to know to understand what’s going on:

1. The signature of zip: zip(*iterables) This means zip expects an arbitrary number of arguments each of which must be iterable. E.g. zip([1, 2], [3, 4], [5, 6]) .
2. Unpacked argument lists: Given a sequence of arguments args , f(*args) will call f such that each element in args is a separate positional argument of f .
3. itertools.zip_longest does not discard any data if the number of elements of the nested lists are not the same (homogenous), and instead fills in the shorter nested lists then zips them up.

Coming back to the input from the question l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] , zip(*l) would be equivalent to zip([1, 2, 3], [4, 5, 6], [7, 8, 9]) . The rest is just making sure the result is a list of lists instead of a list of tuples.

30k 9 9 gold badges 63 63 silver badges 85 85 bronze badges
answered Jun 24, 2011 at 20:59
8,276 1 1 gold badge 25 25 silver badges 23 23 bronze badges

Beware: if l is not evenly sized (say, some rows are shorter than others), zip will not compensate for it and instead chop away rows from the output. So l=[[1,2],[3,4],[5]] gives you [[1,3,5]] .

Sep 13, 2013 at 12:12
The itertools function zip_longest() works with uneven lists. See DOCS
Jan 1, 2015 at 0:39
An explanation in answer would be nice 🙂
May 26, 2018 at 9:03
I think even list(zip(*l)) works correctly in Python 3.
Sep 14, 2018 at 21:34

@Stefano It works (as does zip(*l) in Python 2), but you get a list of tuples, not a list of lists. Of course, list(list(it)) is always the same thing as list(it) .

Sep 21, 2018 at 18:26

Equivalently to Jena’s solution:

>>> l=[[1,2,3],[4,5,6],[7,8,9]] >>> [list(i) for i in zip(*l)] . [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

answered Jun 24, 2011 at 21:02
inspectorG4dget inspectorG4dget
112k 28 28 gold badges 151 151 silver badges 245 245 bronze badges

As list comprehension is now preferred to map() , this solution is the one which is the most in the Python spirit.

Jan 15, 2015 at 13:29

One way to do it is with NumPy transpose. For a list, a:

>>> import numpy as np >>> np.array(l).T.tolist() [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

Or another one without zip (python < 3):

>>> map(list, map(None, *l)) [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

Or for python >= 3:

>>> list(map(lambda *x: list(x), *l)) [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

answered Jun 24, 2011 at 20:59
22.6k 8 8 gold badges 44 44 silver badges 57 57 bronze badges

Love your second one — I didn’t realize map could do that. Here’s a slight refinement that doesn’t require 2 calls, though: map(lambda *a: list(a), *l)

Nov 8, 2013 at 11:51
Shouldnt this be a better answer as it takes care of uneven lists?
Jun 1, 2014 at 17:34

map(None, . ) doesn’t seem to work for Py3. The generator is created but next() raises an error immediately: TypeError: ‘NoneType’ object is not callable .

Sep 13, 2016 at 15:32
@Lee D please can you explain how the code returns expected data —> map(lambda *a: list(a), *l)
Jul 25, 2020 at 14:01
The numpy solution does not do jagged lists.
Dec 20, 2020 at 14:11

just for fun, valid rectangles and assuming that m[0] exists

>>> m = [[1,2,3],[4,5,6],[7,8,9]] >>> [[row[i] for row in m] for i in range(len(m[0]))] [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

1,108 3 3 gold badges 14 14 silver badges 29 29 bronze badges
answered Jun 24, 2011 at 21:06
19.4k 5 5 gold badges 45 45 silver badges 48 48 bronze badges

this is what I was looking for and couldn’t get my head around. Still @jena’s solution is really short

Jun 24, 2011 at 21:12
Yeah, it took a few tires to get this right. Okay, many tries.
Jun 25, 2011 at 4:07

Still isn’t quite right — this only happens to work when the dimensions are square! It should be: [[j[i] for j in l] for i in range(len(l[0]))] . Of course, you have to be sure that list l is not empty.

May 27, 2013 at 19:41
@LeeD still doesn’t work for me on jena’s example l=[[1,2],[3,4],[5]]
Oct 4, 2013 at 22:24

@hobs That was badp’s example, responding to jena. However, I’m not sure it makes sense to me. IMO, transposition implies a rectangular matrix — when represented as a list of lists, that means all the internal lists must be the same length. What result would you want as the «transposition» of this example?

Nov 8, 2013 at 11:30

Methods 1 and 2 work in Python 2 or 3, and they work on ragged, rectangular 2D lists. That means the inner lists do not need to have the same lengths as each other (ragged) or as the outer lists (rectangular). The other methods, well, it’s complicated.

the setup

import itertools import six list_list = [[1,2,3], [4,5,6, 6.1, 6.2, 6.3], [7,8,9]] 

method 1 — map() , zip_longest()

>>> list(map(list, six.moves.zip_longest(*list_list, fillvalue='-'))) [[1, 4, 7], [2, 5, 8], [3, 6, 9], ['-', 6.1, '-'], ['-', 6.2, '-'], ['-', 6.3, '-']] 

• itertools.izip_longest() in Python 2
• itertools.zip_longest() in Python 3

The default fillvalue is None . Thanks to @jena’s answer, where map() is changing the inner tuples to lists. Here it is turning iterators into lists. Thanks to @Oregano’s and @badp’s comments.

In Python 3, pass the result through list() to get the same 2D list as method 2.

method 2 — list comprehension, zip_longest()

>>> [list(row) for row in six.moves.zip_longest(*list_list, fillvalue='-')] [[1, 4, 7], [2, 5, 8], [3, 6, 9], ['-', 6.1, '-'], ['-', 6.2, '-'], ['-', 6.3, '-']] 

method 3 — map() of map() — broken in Python 3.6

>>> map(list, map(None, *list_list)) [[1, 4, 7], [2, 5, 8], [3, 6, 9], [None, 6.1, None], [None, 6.2, None], [None, 6.3, None]] 

This extraordinarily compact @SiggyF second alternative works with ragged 2D lists, unlike his first code which uses numpy to transpose and pass through ragged lists. But None has to be the fill value. (No, the None passed to the inner map() is not the fill value. It means there is no function to process each column. The columns are just passed through to the outer map() which converts them from tuples to lists.)

Somewhere in Python 3, map() stopped putting up with all this abuse: the first parameter cannot be None, and ragged iterators are just truncated to the shortest. The other methods still work because this only applies to the inner map().

method 4 — map() of map() revisited

>>> list(map(list, map(lambda *args: args, *list_list))) [[1, 4, 7], [2, 5, 8], [3, 6, 9]] // Python 2.7 [[1, 4, 7], [2, 5, 8], [3, 6, 9], [None, 6.1, None], [None, 6.2, None], [None, 6.3, None]] // 3.6+ 

Alas the ragged rows do NOT become ragged columns in Python 3, they are just truncated. Boo hoo progress.

Работа с матрицами в python

Привет, Хабр! Я недавно начал свой путь в data science и хочу поделиться свои опытом в написание алгоритмов для работы с матрицами, я планирую активно пополнять свой репозиторий новыми функциями (понимаю что можно все сделать с нампаем).

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

Во-первых, что такое транспонирование, это операция в последствие которой строки и столбцы меняются местами.

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

def transpose_matrix(matrix: list[list]) -> list[list]: transposed_matrix = [[0 for i in range(len(matrix))] for i in range(len(matrix[0]))] for i in range(len(matrix)): for j in range(len(matrix[0])): transposed_matrix[j][i] = matrix[i][j] return transposed_matrix

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

Ранг матрицы

Ранг матрицы — наивысший из порядков всевозможных ненулевых миноров этой матрицы.

def rank_of_matrix(matrix: list[list]) -> int: rank = min(len(matrix), len(matrix[0])) row_index = 0 for i in range(len(matrix[0])): found_nonzero = False for j in range(row_index, len(matrix)): if matrix[j][i] != 0: found_nonzero = True matrix[row_index], matrix[j] = matrix[j], matrix[row_index] break if found_nonzero: for j in range(row_index + 1, len(matrix)): factor = matrix[j][i] / matrix[row_index][i] for k in range(i, len(matrix[0])): matrix[j][k] -= matrix[row_index][k] * factor row_index += 1 return rank

В самом начале в переменная rank инициализируется минимальным значением между количеством строк и количеством столбцов в матрице. Это определяется тем, что ранг матрицы не может быть больше, чем количество строк или столбцов, row_index равна нулю, так как это будет индексом строки, с котором мы будем работать на каждом шаге. Так же проходимся двумя циклами и ищем первый ненулевой элемент в текущем столбце. Если такой элемент найден, он меняется местами. Это делается для того, чтобы разместить ненулевой элемент на позиции ( row_index, i ) . Если найден ненулевой элемент в текущем столбце на позиции ( row_index, i ) , производится процесс приведения матрицы к ступенчатому виду. Для этого вычисляется коэффициент factor, равный matrix[j][i] / matrix[row_index][i], и затем вычитается matrix[row_index][k] * factor из всех элементов строки j, начиная с позиции i. Это приводит к обнулению всех элементов ниже matrix[row_index][i] в столбце i. Увеличиваем row_index на 1, чтобы перейти к следующей строке и продолжить процесс приведения к ступенчатому виду. По окончании алгоритма возвращается rank, которая представляет собой максимальное количество линейно независимых строк или столбцов в матрице.

Инверсия матрицы

Обратная матрица — это матрица, которая умножается на исходную матрицу таким образом, что их произведение дает единичную матрицу. Другими словами, если у нас есть матрица A и ее обратная матрица обозначается как A^-1.

def inverse_matrix(matrix: list[list]) -> list[list]: augmented_matrix = [ [ matrix[i][j] if j < len(matrix) else int(i == j - len(matrix)) for j in range(2 * len(matrix)) ] for i in range(len(matrix)) ] for i in range(len(matrix)): pivot = augmented_matrix[i][i] if pivot == 0: raise ValueError("Matrix is not invertible") for j in range(2 * len(matrix)): augmented_matrix[i][j] /= pivot for j in range(len(matrix)): if i != j: scalar = augmented_matrix[j][i] for k in range(2 * len(matrix)): augmented_matrix[j][k] -= scalar * augmented_matrix[i][k] inverse = [ [augmented_matrix[i][j] for j in range(len(matrix), 2 * len(matrix))] for i in range(len(matrix)) ] return inverse

Переменная augmented_matrix представляет собой расширенную матрицу, добавив единичную матрицу справа. Происходит итерация, получаем значение pivot, которое является текущим диагональным элементом. Если pivot равна 0, вызывается исключение, так как матрица не обратима. Далее делаем нормирование строки, делим все элементы строки на pivot. Это делается для того, чтобы текущий диагональный элемент стал равным 1. Внутренний цикл итерируется по всем столбцам расширенной матрицы. Вычитаем из текущей строки другие строки, умноженные на значение элемента scalar. После завершения внутреннего цикла, матрица будет приведена к верхнетреугольному виду. Создается матрица inverse, которая содержит элементы справа от вертикальной черты в augmented_matrix. Возвращается матрица inverse, которая представляет собой обратную матрицу исходной матрицы.

Заключение

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

Спасибо за выделенное время! Надеюсь было интересно, пишите свои мысли, критикуйте, буду рад исправиться и писать лучшие статьи.

Как транспонировать матрицу в Python

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

Итак, матрица состоит из строк и столбцов. Создать матрицу можно по-разному, но самый простой способ – использовать вложенные списки, как показано ниже:

matrix = [[1, 2, 4], [31, 17, 15]]

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

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

Метод 1. Транспонирование матрицы с помощью NumPy transpose()

Первый метод, который мы разберем, — это использование библиотеки NumPy. NumPy в основном работает с массивами в Python, а для транспонирования мы можем вызвать метод transpose() .

Давайте разберем всё по порядку. Для начала нам нужно импортировать модуль NumPy как np .

Дальше, в ячейке номер [25] мы создаем массив NumPy с именем arr_matrix .

В ячейке номер [26] мы вызываем метод transpose() для нашей матрицы – объекта arr_matrix , который мы создали ранее.

В ячейке номер [27] мы выводим на экран исходную матрицу arr_matrix .

А в ячейке номер [28] – транспонированную матрицу arr_transpose . Можем заметить, что в результате мы получили именно то, что нам было нужно – транспонированную матрицу.

Метод 2. Использование метода numpy.transpose()

Мы также можем транспонировать матрицу в Python с помощью numpy.transpose() . При этом мы передаем матрицу в метод transpose() в качестве аргумента.

В ячейке номер [29] мы создаем матрицу, используя массив NumPy, с именем arr_matrix .

Далее мы передаем arr_matrix в метод transpose() и сохраняем результат в новую переменную arr_transpose .

В ячейке номер [31] мы печатаем исходную матрицу arr_matrix .

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

Метод 3. Транспонирование матрицы с использованием библиотеки SymPy

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

Сначала нам, конечно же, нужно импортировать библиотеку SymPy. Она не поставляется вместе с Python по умолчанию, поэтому вы должны установить её в своей системе, иначе код не будет работать.

В ячейке номер [34] мы создаем матрицу с помощью библиотеки sympy.

Дальше, в ячейке [35], мы вызываем transpose (T) при помощи точечного оператора и сохраняем результаты в новую переменную sympy_transpose .

В ячейке номер [36] мы печатаем исходную матрицу matrix . А в ячейке номер [37] – транспонированную матрицу sympy_transpose . Как видим, у нас получилась транспонированная матрица.

Метод 4. Транспонирование матрицы с использованием вложенного цикла

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

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

В ячейке номер [38] мы создаем матрицу и выводим ее на экран.

В следующей ячейке мы применяем «питонический» способ узнать размерность транспонированной матрицы, используя исходную. А именно — используем генератор списков со вложенными циклами for .

В ячейке [40] мы запускаем два цикла for . Внешний цикл предназначен для строк, а вложенный – для столбцов.

В ячейке номер [41] мы выводим исходную матрицу Matrix . А в ячейке [42] — транспонированную матрицу trans_Matrix .

Метод 5. Использование генератора списка

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

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

Затем в ячейке номер [44] мы используем вложенные циклы, как и в предыдущем примере. Однако здесь мы делаем это в одну строчку, используя генератор списков. Более того, тут нет никакой необходимости менять индексы [j] [i] местами, как мы это делали в предыдущий раз.

В следующей ячейке мы выводим исходную матрицу m . После этого в ячейке номер [42] выводим транспонированную матрицу trans_m . Как видим, желаемый результат получен.

Метод 6. Транспонирование матрицы с помощью pymatrix

Pymatrix – ещё одна облегченная библиотека для матричных операций в Python. Мы можем выполнить транспонирование и с её помощью.

В ячейке номер [43] мы импортируем библиотеку pymatrix. Она не поставляется вместе с Python по умолчанию, поэтому, чтобы код работал корректно, нужно установить ее в своей системе перед использованием.

Затем при помощи библиотеки pymatrix мы создаем матрицу (в ячейке [44]).

В ячейке номер [45] вызываем метод trans() для нашей матрицы и сохраняем результаты в новую переменную pymatrix_transpose.

Потом мы выводим на экран исходную матрицу matrix . А в ячейке номер [47] выводим уже транспонированную матрицу pymatrix_transpose . Как видим, код отработал правильно.

Метод 7. Использование метода zip

Zip – еще один метод транспонирования матрицы.

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

В ячейке номер [64] мы передаем матрицу в zip с помощью оператора * . Мы вызываем каждую строку, а затем преобразуем эту строку в новый список, который становится транспонированной матрицей.

Заключение

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

Мы также познакомились с несколькими новыми библиотеками, такими как pymatrix и sympy.

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