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

Как из списка сделать массив python

  • автор:

Как преобразовать список в массив NumPy (с примерами)

Вы можете использовать следующий базовый синтаксис для преобразования списка в Python в массив NumPy:

import numpy as np my_list = [1, 2, 3, 4, 5] my_array = np.asarray (my_list) 

В следующих примерах показано, как использовать этот синтаксис на практике.

Пример 1: преобразование списка в массив NumPy

Следующий код показывает, как преобразовать список в Python в массив NumPy:

import numpy as np #create list of values my_list = [3, 4, 4, 5, 7, 8, 12, 14, 14, 16, 19] #convert list to NumPy array my_array = np.asarray (my_list) #view NumPy array print(my_array) [ 3 4 4 5 7 8 12 14 14 16 19] #view object type type (my_array) numpy.ndarray 

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

import numpy as np #create list of values my_list = [3, 4, 4, 5, 7, 8, 12, 14, 14, 16, 19] #convert list to NumPy array my_array = np.asarray (my_list, dtype=np.float64 ) #view data type of NumPy array print(my_array. dtype ) float64 

Пример 2: преобразование списка списков в массив массивов NumPy

В следующем коде показано, как преобразовать список списков в массив массивов NumPy:

import numpy as np #create list of lists my_list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] #convert list to NumPy array my_array = np.asarray (my_list_of_lists) #view NumPy array print(my_array) [[1 2 3] [4 5 6] [7 8 9]] 

Затем мы можем использовать функцию формы , чтобы быстро получить размеры нового массива массивов:

print(my_array. shape ) (3, 3) 

Это говорит нам о том, что массив массивов NumPy имеет три строки и три столбца.

Дополнительные ресурсы

В следующих руководствах объясняется, как выполнять другие распространенные преобразования данных в Python:

Python.v.JavaScript

JavaScript for Pythonistas. Python for JavaScripters

Списки / массивы

Стандартная структура данных для хранения нескольких элементов в определённом порядке в Python называется списком ( list ), в JavaScript называется массивом ( Array ).

my_list = [3, 2, 10, "Hello"] my_list
[3, 2, 10, 'Hello']
var my_array = [3, 2, 10, "Hello"];my_array;
[ 3, 2, 10, 'Hello' ]
my_list = list('Hello!') my_list
['H', 'e', 'l', 'l', 'o', '!']
var my_array = Array(1, 2, 3, "Hello");my_array;
[ 1, 2, 3, 'Hello' ]
var my_array = new Array(1, 2, 3, "Hello");my_array;
[ 1, 2, 3, 'Hello' ]
var my_array = new Array(4);my_array;
var my_array = new Array("4");my_array;
var my_array = new Array("Hello!");my_array;
[ 'Hello!' ]

В JavaScript массивы можно создавать, используя функцию Array (со словом new или без него: эффект одинаковый). Если эта функция получает в качестве аргумента одно целое число, то это число принимается за длину массива, который нужно создать, при этом создаётся массив с пустыми слотами. В иных случаях (несколько аргументов, аргумент-строка) создается массив, элементами которого являются перечисленные аргументы. Из-за непоследовательного поведения этой функции и получающихся массивов с пустыми слотами этот метод является не рекомендуемым, подробнее см. в YDKJS.

my_list = [3, 2, 10, "Hello"] my_list[0]
my_list[1]
my_list[-1]
'Hello'
var my_array = [3, 2, 10, "Hello"];my_array[0];
my_array[1];
my_array[my_array.length-1];
Hello
my_list = [2, 3, 10] my_list["0"] 
Exception: TypeError list indices must be integers or slices, not str
var my_array = [2, 3, 10];my_array["0"];

В JavaScript массивы являются частным случаем объектов, а объекты индексируются строками. Числовые индексы неявно преобразуются в строки.

my_list = [3, 2, 10, "Hello"] my_list[0] = 100 my_list
[100, 2, 10, 'Hello']
var my_array = [3, 2, 10, "Hello"]; my_array[0] = 100;my_array;
[ 100, 2, 10, 'Hello' ]
my_list = [3, 2, 10, "Hello"] len(my_list)
var my_array = [3, 2, 10, "Hello"];my_array.length;
my_list = [3, 2, 10, "Hello"] my_list.append(5) my_list
[3, 2, 10, 'Hello', 5]
var my_array = [3, 2, 10, "Hello"]; my_array.push(5);my_array;
[ 3, 2, 10, 'Hello', 5 ]
my_list = [3, 2] my_list.extend([12, 20]) my_list
[3, 2, 12, 20]
var my_array = [3, 2]; my_array.push(12, 20);my_array;
[ 3, 2, 12, 20 ]
my_list = [3, 2, 10, "Hello"] other_list = [1, 2, 3] my_list.extend(other_list) my_list
[3, 2, 10, 'Hello', 1, 2, 3]
var my_array = [3, 2, 10, "Hello"]; var other_array = [1, 2, 3]; my_array.push.apply(my_array, other_array);my_array;
[ 3, 2, 10, 'Hello', 1, 2, 3 ]
var my_array = [3, 2, 10, "Hello"]; var other = [1, 2, 3]; Array.prototype.push.apply(my_array, other);my_array;
[ 3, 2, 10, 'Hello', 1, 2, 3 ]
function extend(arr, other) < /* you should include a test to * check whether other_array really * is an array */ other.forEach(function(v) < arr.push(v); >); > var my_array = [3, 2, 10, "Hello"]; var other_array = [1, 2, 3]; extend(my_array, other_array);my_array;
[ 3, 2, 10, 'Hello', 1, 2, 3 ]

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

var my_array = [3, 2, 10, "Hello"]; var other_array = [1, 2, 3]; my_array.push(. other_array);my_array;
[ 3, 2, 10, 'Hello', 1, 2, 3 ]
first_list = [1, 2, 3] second_list = ["Hello", "World"] new_list = first_list + second_list new_list
[1, 2, 3, 'Hello', 'World']
first_array = [1, 2, 3]; second_array = ["Hello", "World"]; new_array = first_array.concat(second_array);new_array;
[ 1, 2, 3, 'Hello', 'World' ]
my_list = [2, 10, 15] del my_list[1] my_list
[2, 15]
my_list[1]
len(my_list)
var my_array = [2, 10, 15]; delete my_array[1];my_array;
[ 2, , 15 ]
my_array[1];
undefined
my_array.length;
my_list = [1, 2, 10] my_list.clear() my_list
var my_array = [1, 2, 10] my_array.length = 0my_array;
my_list = [1, 20, 10] my_list[3] 
Exception: IndexError list index out of range
var my_array = [1, 20, 10]my_array[3];
undefined
my_list = [1, 2, 10] my_list[5] = 100 
Exception: IndexError list assignment index out of range
var my_array = [1, 2, 10] my_array[5] = 100my_array;
[ 1, 2, 10, , 100 ]
my_array[3];
undefined
my_array[5];
my_list = [1, 7, 10] 1 in my_list
True
7 in my_list
True
10 in my_list
True
2 in my_list
False
"1" in my_list
False

Оператор in для списков проверяет, находится ли элемент в списке.

list_like_dict = < 0: 1, 1: 7, 2: 10 >1 in list_like_dict
True
7 in list_like_dict
False
10 in list_like_dict
False
2 in list_like_dict
True
"1" in list_like_dict
False

Если сделать словарь, похожий на список (с числовыми ключами), то оператор in будет проверять, находится ли данный элемент среди индексов (как это всегда происходит со словарями). Примерно так работает аналогичный оператор в JavaScript.

var my_array = [1, 7, 10];1 in my_array;
true
7 in my_array;
false
10 in my_array;
false
2 in my_array;
true
"1" in my_array;
true

Поскольку массив в JavaScript — это частный случай объекта (то есть штуки, похожей на словарь), in проверяет, есть ли данный элемент среди индексов (ключей), а не среди значений. См. этот ответ по поводу проверки на наличие элемента среди значений.

my_list = [0, 10, 20, 30, 40, 50, 60] my_list[2:4]
[20, 30]
my_list[:2]
[0, 10]
my_list[2:]
[20, 30, 40, 50, 60]
my_list[2:-2]
[20, 30, 40]
my_list[:]
[0, 10, 20, 30, 40, 50, 60]
my_list[2:6:2]
[20, 40]
my_list[4:2:-1]
[40, 30]
my_array = [0, 10, 20, 30, 40, 50, 60]my_array.slice(2, 4);
[ 20, 30 ]
my_array.slice(null, 2);
[ 0, 10 ]
my_array.slice(2);
[ 20, 30, 40, 50, 60 ]
my_array.slice(2, -2);
[ 20, 30, 40 ]
my_array.slice();
[ 0, 10, 20, 30, 40, 50, 60 ]

Срезов с шагом (третий аргумент в Python) в JavaScript по умолчанию нет.

my_list = [0, 10, 20, 30, 40] my_list[2:4] = [200, 300, 400] my_list
[0, 10, 200, 300, 400, 40]
my_list[1:2] = [] my_list
[0, 200, 300, 400, 40]
my_list[3:3] = [999] my_list
[0, 200, 300, 999, 400, 40]
var my_array = [0, 10, 20, 30, 40]; var deleted; deleted = my_array.splice(2, 2, 200, 300, 400);my_array;
[ 0, 10, 200, 300, 400, 40 ]
deleted;
[ 20, 30 ]
my_array.splice(1, 1);my_array;
[ 0, 200, 300, 400, 40 ]
my_array.splice(3, 0, 999);my_array;
[ 0, 200, 300, 999, 400, 40 ]

Метод splice(start, deleteCount, item1, item2, . ) редактирует массив in place: удаляет deleteCount элементов, начиная с start , затем добавляет элементы item1 , item2 , и т.д.

© Ilya V. Schurov and contributors, 2017
Licenses: CC BY (text), MIT (code).
contribute on github

Язык

  • Английский (English)
  • Русский (Russian)

Темы

  • Списки / массивы
  • Цикл for
  • Словари / объекты
  • Области видимости
  • Типы и сравнение
  • Функции

Многомерные массивы в Numpy — Python: Numpy-массивы

Библиотека Numpy дает мощный и удобный высокоуровневый аппарат для работы с многомерными данными. Для работы с ними в Numpy разработана своя собственная структура данных — массив numpy.ndarray . Именно под эту структуру оптимизирована работа всего функционала библиотеки.

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

Структура данных библиотеки Numpy

Чтобы создать структуру numpy.ndarray , нужно конвертировать список list . Для конвертации из множества set требуется дополнительное приведение типа данных.

Рассмотрим на таком примере:

# Импортируем библиотеку numpy с псевдонимом np import numpy as np # Создаем простой пример списка языка Python simple_list = [1, 2, 3, 4, 5] # Конвертируем созданный список в массив Numpy my_first_ndarray = np.array(simple_list, dtype=int) # Тип созданного объекта print(type(my_first_ndarray)) # => # Результат стандартного вывода print(my_first_ndarray) # => [1 2 3 4 5] 

А теперь разберем этот код подробнее. Сам пример показывает встроенную функциональность для создания структуры numpy.ndarray . Мы импортируем библиотеку Numpy, создаем короткий список значений simple_list , а затем конвертируем в массив my_first_ndarray . Для этого вызываем конструктор np.array() с объектами для конвертации.

С учетом примера выше, обратная конвертация в список происходит так:

print(ndarray_from_list.tolist()) 

Конвертация из списка Python — это самая популярная операция, с помощью которой создается структура numpy.ndarray .

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

Но при разработке сложных программ модуль numpy.ndarray может быть только частью общей структуры. В таких случаях используют стандартные типы данных языка для обмена данными между функциональными частями программ.

В итоге порядок работы с данными при работе с Numpy выглядит следующим образом:

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

Допустимые типы данных

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

# Проверяем тип полученного массива print(my_first_ndarray.dtype.type) # => 

Как и ожидалось, тип данных — int64. Необязательно ограничиваться только им:

# Целочисленный массив print(np.array([1, 2, 3], dtype=int).dtype.type) # => # Массив строк print(np.array([1, 2, 3], dtype=str).dtype.type) # => # Массив чисел с плавающей запятой print(np.array([1, 2, 3], dtype=float).dtype.type) # => 

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

# Все элементы списка целочисленные print(np.array([1, 2, 3]).dtype.type) # => # Все элементы списка — это строки print(np.array(['1', '2', '3']).dtype.type) # => # Элементы списка как текстовые, так и целочисленные print(np.array(['1', 2, 3]).dtype.type) # => 

Заметим, что ошибки при конвертации смешанного типа элементов массива не произошло. Конвертор просто привел все данные к строковому типу.

Как Numpy работает на практике

Функциональность библиотеки Numpy настолько интуитивна, что уже сейчас можно решить простую аналитическую задачку.

Представим продажи ноутбуков в магазине за одну неделю:

День Магазин №1
0 7
1 4
2 3
3 8
4 15
5 21
6 25

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

Поработаем с данными с помощью библиотеки Numpy:

# Импортируем библиотеку numpy с псевдонимом np import numpy as np # Создаем список продаж — представим, что считали его из базы данных orders_list = [7, 4, 3, 8, 15, 21, 25] # Конвертируем созданный список в массив Numpy orders_ndarray = np.array(orders_list, dtype=int) # Тип созданного объекта print(type(orders_ndarray)) # => # Результат стандартного вывода print(orders_ndarray) # => [ 7 4 3 8 15 21 25] 

Попробуем найти день недели с самыми низкими продажами. Опыт работы с Python подсказывает, что метод будет называться min() или minimum() . Найдем минимальное количество продаж и заодно день недели, в который оно совершено:

# Находим минимальный элемент массива print(orders_ndarray.min()) # => 3 # Находим порядковый номер минимального элемента массива print(orders_ndarray.argmin()) # => 2 

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

# Находим максимальный элемент массива print(orders_ndarray.max()) # => 25 

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

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

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

День Магазин №1 Магазин №2 Магазин №3 Магазин №4
0 7 1 7 8
1 4 2 4 5
2 3 5 2 3
3 8 12 8 7
4 15 11 13 9
5 21 18 17 21
6 25 16 25 17

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

# Импортируем библиотеку numpy с псевдонимом np import numpy as np # Создаем «список списков продаж» orders_list = [ [7, 1, 7, 8], [4, 2, 4, 5], [3, 5, 2, 3], [8, 12, 8, 7], [15, 11, 13, 9], [21, 18, 17, 21], [25, 16, 25, 17] ] # Конвертируем созданный «список списков» в массив Numpy orders_ndarray = np.array(orders_list, dtype=int) # Описываем тип созданного объекта print(type(orders_ndarray)) # => # Находим минимальный элемент массива print(orders_ndarray.min()) # => 1 

В приведенном примере метод min() находит минимальный элемент среди всех значений массива.

Большинство функций в Numpy реализованы так, что методы и функции выполняют одинаковые операции, вне зависимости от типа данных на входе.

В программировании такой подход называется полиморфизмом. Он упрощает разработку и делает код более простым для анализа и поддержки.

Выводы

Сегодня мы познакомились с основной структурой данных библиотеки Numpy — массивом numpy.ndarray .

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

  • 130 курсов, 2000+ часов теории
  • 1000 практических заданий в браузере
  • 360 000 студентов

Наши выпускники работают в компаниях:

Преобразование массива NumPy в список

Объекты [np.array] в NumPy можно преобразовывать в списки с помощью функции tolist(). Функция tolist() не принимает никаких аргументов. Если массив одномерный, она возвращает список с элементами массива. Для многомерного массива возвращается вложенный список.

Преобразование одномерного массива NumPy в список

Для примера давайте создадим одномерный массив:

import numpy as np # 1d array to list arr_1 = np.array([1, 2, 3]) print(f'NumPy Array:\n')

Данный код вернет такой результат:

NumPy Array: [1 2 3]

А теперь попробуем применить функцию tolist():

import numpy as np # 1d array to list arr_1 = np.array([1, 2, 3]) print(f'NumPy Array:\n') list_1 = arr_1.tolist() print(f'List: ')

Новый код вернет:

List: [1, 2, 3]

Как видите, массив был преобразован в список.

Преобразование многомерного массива NumPy в список

Давайте теперь построим многомерный массив:

import numpy as np # 2d array to list arr_2 = np.array([[1, 2, 3], [4, 5, 6]]) print(f'NumPy Array:\n')

Этот код выведет следующий массив:

NumPy Array: [[1 2 3] [4 5 6]]

А теперь давайте применим функцию tolist():

import numpy as np # 2d array to list arr_2 = np.array([[1, 2, 3], [4, 5, 6]]) print(f'NumPy Array:\n') list_2 = arr_2.tolist() print(f'List: ')

Этот код выведет такой результат:

List: [[1, 2, 3], [4, 5, 6]]

Массив был преобразован из скаляров numpy в скаляры Python.

Заключение

В этой статье мы показали, как использовать функцию tolist() для преобразования объектов np.array в списки. Функцию можно применять как к одномерным, так и к многомерным массивам.

Читайте также:

  • Документация API
  • Обнаружение и распознавание лиц на фотографиях

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

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