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

Массив в Python

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

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

Итак, мы разберем следующие темы:

1. Введение в массивы
   • Основные различия между списками и массивами
   • Когда нужно использовать массивы
2. Как использовать массив в Python
   • Определение массива
   • Поиск длины массива
   • Индексация массива
   • Поиск элементов в массиве
   • Использование циклов с массивами
   • Срезы массивов
3. Методы массивов для выполнения различных операций
   • Изменение существующего значения
   • Добавление нового значения
   • Удаление значения
4. Заключение

Что ж, давайте приступать!

Что такое массив в Python?

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

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

В чем разница между списками и массивами в Python?

Списки — одна из наиболее распространенных структур данных в Python и основная часть языка.

Списки и массивы ведут себя сходным образом.

Как и массивы, списки представляют собой упорядоченную последовательность элементов.

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

Однако списки и массивы — это не одно и то же.

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

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

Когда следует использовать массивы в Python

Списки встроены по умолчанию в язык программирования Python, а массивы — нет. Поэтому, если вы хотите использовать массивы, их сперва нужно импортировать через модуль array .

Массивы модуля array представляют собой тонкую обертку массивов в C. Они полезны, когда вам нужно работать с однородными данными.

Они также более компактны и занимают меньше памяти и места, что делает их более эффективными по сравнению со списками.

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

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

Как использовать массивы в Python

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

Импортировать модуль массива можно тремя способами:

1. Использовать import array в верхней части файла. Это позволит нам подключить модуль array . После чего мы сможем создать массив, используя array.array() .

import array # Создание массива array.array()

2. Чтобы не вводить постоянно array.array() , можно прописать import array as arr в верхней части файла вместо просто import array . После чего для создания массива нужно будет набрать arr.array() . Arr действует как псевдоним, после которого сразу следует конструктор для создания массива.

import array as arr # Создание массива arr.array()

3. Наконец, вы также можете использовать from array import * , где с помощью * импортируются все доступные функции данного модуля. В таком случае, чтобы создать массив, нужно написать просто array() .

from array import * # Создание массива array()

Как определить массив в Python

После того, как вы импортировали модуль array, вы можете перейти к непосредственному созданию массива Python.

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

variable_name = array(typecode,[elements])

Давайте разберем синтаксис подробнее:

• variable_name будет именем массива
• typecode указывает, какие элементы будут храниться в массиве. Это может быть массив целых чисел, массив чисел с плавающей запятой или массив любого другого типа данных в Python. Но помните, что все элементы должны быть одного типа данных.
• Внутри квадратных скобок вы указываете элементы, которые будут храниться в массиве, при этом каждый элемент отделяется запятой. Вы также можете создать пустой массив, просто написав variable_name = array(typecode) без каких-либо элементов.

Ниже приведена таблица кодов для различных типов данных.

TYPECODE	Тип в C	Тип в Python	Размер
‘b’	signed char	int	1
‘B’	unsigned char	int	1
‘u’	wchar_t	Unicode character	2
‘h’	signed short	int	2
‘H’	unsigned short	int	2
‘i’	signed int	int	2
‘I’	unsigned int	int	2
‘l’	signed long	int	4
‘L’	unsigned long	int	4
‘q’	signed long long	int	8
‘Q’	unsigned long long	int	8
‘f’	float	float	4
‘d’	double	float	8

Создание массива на практике

Вот пример того, как можно определить массив в Python:

import array as arr numbers = arr.array('i',[10,20,30]) print(numbers) #output #array('i', [10, 20, 30])

Давайте разберем, что мы только что сделали.

Сначала мы подключили модуль array , в данном случае с помощью import array as arr .

Затем мы создали массив чисел.

Мы использовали arr.array() , так как arr это наш псевдоним для модуля.

Внутри конструктора array() мы сначала указали i для целых чисел. Это означает, что массив может включать как положительные, так и отрицательные значения. Если бы мы, например, указали H , это бы означало, что отрицательные значения не допускаются.

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

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

import array as arr numbers = arr.array('i',[10.0,20,30]) print(numbers) #output #Traceback (most recent call last): # File "/Users/dionysialemonaki/python_articles/demo.py", line 14, in # numbers = arr.array('i',[10.0,20,30]) #TypeError: 'float' object cannot be interpreted as an integer

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

Другой способ создания массива:

from array import * # Массив чисел с плавающей запятой numbers = array('d',[10.0,20.0,30.0]) print(numbers) #output #array('d', [10.0, 20.0, 30.0])

В этом примере модуль массива был импортирован через from array import * . Затем был создан массив чисел с типом данных float . Это означает, что он содержит только числа с плавающей запятой, которым соответствует код d .

Как найти длину массива в Python

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

Он вернет вам целое число, равное общему количеству элементов в указанном вами массиве.

import array as arr numbers = arr.array('i',[10,20,30]) print(len(numbers)) #output # 3

В этом примере массив содержал три элемента — 10 , 20 , 30 . Поэтому длина массива равна 3.

Индексация массива и доступ к отдельным элементам

Каждый элемент массива имеет определенный адрес. Доступ к отдельным элементам осуществляется путем ссылки на их порядковый номер.

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

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

Общий синтаксис будет выглядеть так:

array_name[index_value_of_item]

Вот так можно получить доступ к каждому отдельному элементу в массиве:

import array as arr numbers = arr.array('i',[10,20,30]) print(numbers[0]) # Получение 1-го элемента print(numbers[1]) # Получение 2-го элемента print(numbers[2]) # Получение 3-го элемента #output #10 #20 #30

Помните, что значение индекса последнего элемента массива всегда на единицу меньше, чем длина массива. Если n — длина массива, то значением индекса последнего элемента будет n-1 .

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

При отрицательной индексации последний элемент будет иметь индекс -1, предпоследний элемент — -2 и так далее.

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

import array as arr numbers = arr.array('i',[10,20,30]) print(numbers[-1]) # Получение последнего элемента print(numbers[-2]) # Получение предпоследнего элемента print(numbers[-3]) # Получение первого элемента #output #30 #20 #10

Как искать элемент в массиве в Python

Вы можете узнать порядковый номер элемента с помощью метода index() .

В качестве аргумента метода вы передаете значение искомого элемента, и вам возвращается его индекс.

import array as arr numbers = arr.array('i',[10,20,30]) # Поиск индекса элемента со значением 10 print(numbers.index(10)) #output #0

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

import array as arr numbers = arr.array('i',[10,20,30,10,20,30]) # Поиск индекса элемента со значением 10 # Возвращается индекс первого из двух элементов со значением 10 print(numbers.index(10)) #output #0

Как перебрать массив в Python с помощью цикла

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

Вы также видели, как распечатать массив с помощью метода print() . Этот метод дает следующий результат:

import array as arr numbers = arr.array('i',[10,20,30]) print(numbers) #output #array('i', [10, 20, 30])

Но что делать, если вы хотите вывести значения одно за другим?

Здесь на помощь приходит цикл. Вы можете идти по массиву и распечатывать значения одно за другим с каждой новой итерацией цикла. Подробнее о циклах в Python можно почитать в статье «Pythonic циклы».

К примеру, для решения нашей задачи вы можете использовать простой цикл for :

import array as arr numbers = arr.array('i',[10,20,30]) for number in numbers: print(number) #output #10 #20 #30

Вы также можете использовать функцию range() и передать метод len() в качестве ее параметра. Это даст тот же результат:

import array as arr values = arr.array('i',[10,20,30]) # Распечатка всех значений массива по отдельности for value in range(len(values)): print(values[value]) #output #10 #20 #30

Как использовать срезы с массивами в Python

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

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

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) # Получение только значений 10 и 20 print(numbers[:2]) # С первой по вторую позицию (индексы 0 и 1) #output #array('i', [10, 20])

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

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) # Получение только значений 20 и 30 print(numbers[1:3]) # Со второй по третью позицию #output #array('i', [20, 30])

Методы выполнения операций с массивами в Python

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

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

Изменение значения элемента в массиве

Вы можете изменить значение определенного элемента, указав его позицию (индекс) и присвоив ему новое значение. Сделать это можно так:

import array as arr #original array numbers = arr.array('i',[10,20,30]) # Изменение первого элемента # Меняется значение с 10 на 40 numbers[0] = 40 print(numbers) #output #array('i', [40, 20, 30])

Добавление нового значения в массив

Чтобы добавить одно значение в конец массива, используйте метод append() :

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) # В конец numbers добавляется целое число 40 numbers.append(40) print(numbers) #output #array('i', [10, 20, 30, 40])

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

Посмотрите, что произойдет, если мы пытаемся добавить число с плавающей запятой в массив целых чисел:

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) # В конец numbers добавляется число с плавающей запятой 40.0 numbers.append(40.0) print(numbers) #output #Traceback (most recent call last): # File "/Users/dionysialemonaki/python_articles/demo.py", line 19, in # numbers.append(40.0) #TypeError: 'float' object cannot be interpreted as an integer

Но что, если вы хотите добавить более одного значения в конец массива?

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

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) # Добавление целых чисел 40,50,60 в конец numbers # Числа берутся в квадратные скобки numbers.extend([40,50,60]) print(numbers) #output #array('i', [10, 20, 30, 40, 50, 60])

А что, если вы хотите добавить элемент не в конец массива? В таком случае используйте метод insert() : он позволяет добавить элемент на определенную позицию.

Функция insert() принимает два аргумента: индекс позиции, на которую будет вставлен новый элемент, и значение нового элемента.

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) # Добавление целого числа 40 на первую позицию # Помните, что индексация начинается с 0 numbers.insert(0,40) print(numbers) #output #array('i', [40, 10, 20, 30])

Удаление значения из массива

Чтобы удалить элемент из массива, используйте метод remove() и укажите значение элемента в качестве аргумента.

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30]) numbers.remove(10) print(numbers) #output #array('i', [20, 30])

С помощью remove() будет удален только первый экземпляр значения, которое вы передаете в качестве аргумента.

Посмотрите, что происходит, когда имеется несколько элементов с одинаковым значением:

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30,10,20]) numbers.remove(10) print(numbers) #output #array('i', [20, 30, 10, 20])

Удаляется только первое вхождение числа 10 .

Вы также можете использовать метод pop() и указать позицию удаляемого элемента:

import array as arr # Исходный массив numbers = arr.array('i',[10,20,30,10,20]) # Удаление первого вхождения 10 numbers.pop(0) print(numbers) #output #array('i', [20, 30, 10, 20])

Заключение

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

Спасибо за чтение и успехов в написании кода!

4. Массивы в Python

В Python нет служебных слов, которые обозначают массив (например, как в Pascal — array), вместо этого для хранения массива используют списки (тип данных list).

Список в Python — это набор элементов, который имеет свой номер (индекс).

План работы с массивом

1. Создать массив. Например, так:

N \(= 10\) #известно количество элементов;

N \(=\) int(input(‘Введи количество элементов’)) #неизвестно количество элементов.

2. Заполнить массив.

3. Обработать элементы массива.

4. Вывести результаты обработки.

Способы заполнения массива

С клавиатуры:

Рис. \(2\). Ввод с клавиатуры

Ввод с помощью генератора случайных чисел:

Рис. \(3\). Ввод с помощью случайных чисел

Ввод с помощью формул:

Рис. \(4\). Ввод с помощью формул

В двумерном массиве всё аналогично, только добавляется ещё один индекс:

A:array[\(1\)..N, \(1\)..M] of integer.

Создаём массив в Python: инструкция с простыми примерами

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

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

Что такое массив в Python?

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

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

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

Чем отличаются списки от массивов

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

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

Допустим, нам нужно сделать список с числами, это будет выглядеть так.

numbers = [1, 2, 3, 4, 5]

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

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

Когда следует использовать массивы в Python

Раз списки более удобны, зачем нужны массивы? Оказывается, они компактнее, а также требуют меньше памяти. Поэтому актуальны в следующих ситуациях.

1. Вы собираетесь работать с приложениями, для которых необходим большой объём ресурсов.
2. Вам нужно выполнить низкоуровневую операцию.
3. В проекте используются математические вычисления.

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

Кстати, если массивы вам всё же понадобились, повысить производительность процессов поможет выделенный сервер.

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

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

Также необходим надёжный хостинг, который обеспечит бесперебойную работу ваших проектов. Тем более у вас будет возможность увеличения объёмов хранилища, пропускной способности и других параметров, которые необходимы для обеспечения эффективной работы веб-сайта.

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

Сейчас вы можете заказать перенос сайта в RU-CENTER за 1 рубль https://www.nic.ru/info/master-transfer/.

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

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

Делается это командой.

from array import *

Сам массив создаётся с помощью такого шаблона.

Познакомимся с его структурой.

• array_name — название. Можете придумать другое на своё усмотрение.
• array —функция.
• typecode — тип хранимых данных. Здесь нужно учитывать обозначения. Так i – это целочисленные значения, а d – числа с плавающей запятой.
• В квадратных скобках заключены элементы массива.

Простой массив будет выглядеть так.

>>> from array import *

array(‘i’, [1, 2, 3, 4, 5])

Выполнение операции с массивами

Python предоставляет множество полезных операций для работы с массивами. Давайте рассмотрим их подробнее.

С помощью этой функции можно считать количество элементов. В данном примере мы сделали перечисление, и получили логичный результат – 5.

1. print(array[number]

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

Индексация массива в Python начинается с 0. Это означает, что первый элемент массива имеет индекс 0, второй — 1, третий — 2 и так далее. Для доступа к элементу массива используется квадратные скобки и индекс элемента внутри них. Например, для получения доступа к первому элементу массива требуется выражение array[0].

С помощью print(array[number] нам удаётся индексировать элементы и выводить те, который нам подходят.

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

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

Учитывайте, что индексация массива не ограничивается положительными числами. Негативные индексы также допустимы и используются для доступа к элементам массива в обратном порядке. Последний элемент может быть получен с помощью индекса -1, предпоследний — с помощью индекса -2 и так далее. Например, если необходимо получить доступ к последнему элементу массива, применяйте выражение array[-1].

Обратите внимание, что сейчас на пятёрке ошибки уже нет, поскольку нумерация начинается не с нуля.

Циклы играют важную роль при работе с массивами, так как они позволяют нам выполнять повторяющиеся действия на каждом элементе массива. Можем использовать цикл `for`. Вот как это выглядит в нашем примере.

1. Изменение массива.

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

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

С помощью этого метода удаётся добавить сразу много элементов.

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

В данном случае мы поставили 2.3 на первую позицию. Это число оказалось на втором месте, потому что нумерация начинается с нуля.

Этот метод необходим для удаления элементом. Попробуем убрать число 7.2.

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

А этот метод удаляет элемент с определённой позиции. Попробуем убрать пятый. Как видите в результате лишняя цифра исчезла.

Подведём итоги

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

Как создать массив в Python: инструкция

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

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

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

list = ['element1', 'element2', 'element3']

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

>>> different = ['55', 'string', '32.5', ['list_in_list', '55', 'string', '32.5']]
>>> print(different)
['55', 'string', '32.5', ['list_in_list', '55', 'string', '32.5']]

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

>>> different2 = [55, 'string', 32.5, ['list_in_list', '55', 'string', '32*8']]
>>> print(different2)
[55, 'string', 32.5, ['list_in_list', '55', 'string', '32*8']]

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

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

Работа с массивами

Далее мы не будем рассматривать классические списки ( lists ), по которым написаны отдельные статьи, а сосредоточимся на работе с вызываемыми массивами. Они импортируются при помощи модуля array . Важное замечание: функция array позволяет создавать массивы только из целочисленных значений и чисел с плавающей запятой. Также пока поддерживаются символы Unicode, но поддержку Юникода планируется убрать в следующих версиях Python (начиная с 4.0). Поэтому сосредоточимся на значениях int и float .

Импорт модуля array

Итак, функция array делает доступными массивы в программе на Python. Вызывается она по-разному, удобнее сделать так (минимизирует число последующих ошибок):

from array import *

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

Создание массива

Чтобы создать массив, воспользуйтесь следующим шаблоном:

array_name = array(typecode,[ ])

Рассмотрим каждый элемент массива подробнее:

• array_name — имя (можно задать любое, помня о правилах создания переменных в Python);
• array — собственно функция;
• typecode — тип хранимых данных (для целочисленных значений обычно указывают i , а для чисел с плавающей запятой чаще используют d );
• [ ] — здесь через запятую перечисляются элементы массива.

Теперь попробуем создать простейший массив:

>>> from array import *
>>> integers = array('i',[1,2,3,4,5])
>>> print(integers)
array('i', [1, 2, 3, 4, 5])

Получилось. Давайте создадим массив с числами с плавающей запятой:

>>> from array import *
>>> floats = array('d',[3.5,7.2,5.3,9.5,4.0])
>>> print(floats)
array('d', [3.5, 7.2, 5.3, 9.5, 4.0])

А что будет, если в первом примере мы заменим целое число на число с плавающей запятой?

>>> integers = array('i',[1,2,3,4,5.2])
Traceback (most recent call last): 
File "", line 1, in  
integers = array('i',[1,2,3,4,5.2])
TypeError: integer argument expected, got float

Предсказуемая ошибка, интерпретатор пишет, что ожидает целочисленный аргумент. С другой стороны:

>>> floats = array('d',[3.5,7.2,5.3,9.5,4])
>>> print(floats)
array('d', [3.5, 7.2, 5.3, 9.5, 4.0])

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

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

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

• Функция len() позволяет подсчитать количество элементов:

>>> integers = array('i',[1,2,3,4,5])
>>> print(len(integers))
5

• Также можно индексировать элементы и выводить нужные (для этого используется конструкция print(array[number]) :

>>> floats = array('d',[3.5,7.2,5.3,9.5,4.0])
>>> print(floats[0])
3.5
>>> print(floats[4])
4.0
>>> print(floats[1])
7.2

Обратите внимание, что нумерация в Python всегда начинается с нуля, поэтому, чтобы вызвать первый элемент, мы вводим print(floats[0]) . Соответственно, пятый элемент идет под номером 4. А что будет, если попробовать вызвать элемент за границами массива?

>>> print(floats[5])
Traceback (most recent call last): 
File "", line 1, in  
print(floats[5])
IndexError: array index out of range

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

>>> print(floats[-1])
4.0
>>> print(floats[-2])
9.5
>>> print(floats[-5])
3.5

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

• Доступны и операции с циклами. Вот так выводится последовательность элементов при помощи цикла for :

>>> floats = array('d',[3.5,7.2,5.3,9.5,4.0])
>>> for d in floats:
print(d)

3.5
7.2
5.3
9.5
4.0

• В отличие от строк, массивы и списки в Python изменяемы, поэтому допустимы и такие операции:

>>> floats[1] = 8.2
>>> print(floats)
array('d', [3.5, 8.2, 5.3, 9.5, 4.0])

Значение второго элемента было 7.2, но мы присвоили ему новое — 8.2.

• Если значения элементов меняются, то, наверное, возможно добавить и новый элемент? Это делается при помощи метода append() :

>>> integers = array('i',[1,2,3,4,5])
>>> integers.append(6)
>>> print(integers)
array('i', [1, 2, 3, 4, 5, 6])

Главное, чтобы добавляемый элемент относился к тому же типу данных, что и уже имеющиеся в массиве, иначе интерпретатор выдаст такую ошибку:

>>> integers.append(7.0)
Traceback (most recent call last):
File "", line 1, in  
integers.append(7.0)
TypeError: integer argument expected, got float

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

>>> floats = array('d',[3.5,7.2,5.3,9.5,4.0])
>>> floats.append(8)
>>> print(floats)
array('d', [3.5, 7.2, 5.3, 9.5, 4.0, 8.0])

• Добавить в массив несколько элементов поможет метод extend() . Вводим далее в интерпретаторе:

>>> floats.extend([4.5,5.7,6.9])
>>> print(floats)
array('d', [3.5, 7.2, 5.3, 9.5, 4.0, 8.0, 4.5, 5.7, 6.9])

• А если нам нужно вставить новый элемент на какую-то определенную позицию? Для этого предназначен метод insert() . Делается это так (используем всё тот же измененный массив с floats из примера выше):

>>> floats.insert(1,2.3)
>>> print(floats)
array('d', [3.5, 2.3, 7.2, 5.3, 9.5, 4.0, 8.0, 4.5, 5.7, 6.9])

Мы вставили число 2.3 на вторую позицию (помним про нумерацию, которая начинается с нуля, поэтому вторая позиция будет под номером 1).

• Раз можно добавлять и вставлять элементы, то должен быть и метод их удаления. Он называется remove() :

>>> floats.remove(7.2)
>>> print(floats)
array('d', [3.5, 2.3, 5.3, 9.5, 4.0, 8.0, 4.5, 5.7, 6.9])

А вот, что произойдет, если в массиве несколько элементов с одинаковым значением:

>>> integers = array('i',[11,12,13,14,15,11,11])
>>> integers.remove(11)
>>> print(integers)
array('i', [12, 13, 14, 15, 11, 11])

Удалилось только первое значение 11, а остальные остались в массиве. Для удаления элемента на конкретной позиции предназначен метод pop() :

>>> integers = array('i',[11,12,13,14,15,11,11])
>>> integers.pop(5)
11
>>> print(integers)
array('i', [11, 12, 13, 14, 15, 11])

Число 11 на шестой позиции было удалено из массива.

Заключение

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