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

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

  • автор:

Массивы в Python

Массивы в Python

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

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

Если вы новичок в Python, начните со статьи Введение в Python.

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

from array import *

После того, как вы импортировали array модуль, вы можете объявить массив. Вот как вы это делаете:

arrayIdentifierName = array(typecode, [Initializers])

В приведенном выше объявлении, arrayIdentifierName этого имя массива, typecode позволяет питону знать тип массива и Initializers являются значением , с которыми массив инициализируется.

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

Вот реальный пример объявления массива python:

 my_array = array('i',[1,2,3,4])

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

Вот простой пример массива, содержащего 5 целых чисел

Доступ к отдельным элементам через индексы

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

Добавить любое значение в массив с помощью метода append()

Заметим , что значение 6 был приложен к существующим значениям массива.

Вставить значение в массив с помощью метода insert()

Мы можем использовать insert() метод , чтобы вставить значение в любом индекса массива. Вот пример:

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

Расширение массива python с помощью метода extend()

Массив Python может быть расширен с более чем одно значение с помощью extend() метод. Вот пример:

Мы видим , что my_array массив был расширен со значениями из my_extnd_array .

Добавить элементы из списка в массив, используя метод fromlist()

Итак , мы видим , что значения 11,12 и 13 были добавлены из списка c к my_array .

Удалите любой элемент массива, используя метод remove()

Мы видим, что элемент 4 был удален из массива.

Удалить последний элемент массива методом pop()

pop удаляет последний элемент из массива. Вот пример:

Итак , мы видим , что последний элемент ( 5 ) был выскочили из массива.

Получить любой элемент через его индекс с помощью метода index()

index() возвращает первый индекс значения соответствия. Помните, что массивы с нулевой индексацией.

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

Обратный массив Python, используя метод reverse()

reverse() метод делает то , что название говорит , что это будет делать — изменяет массив. Вот пример:

Получить информацию о буфере массива с помощью метода buffer_info()

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

my_array = array('i', [1,2,3,4,5]) my_array.buffer_info() #(33881712, 5) 

Проверьте количество вхождений элемента с помощью метода count()

count() — count() возвращает число раз , и представляется , что элемент в массиве. В следующем примере мы видим , что значение 3 происходит дважды.

my_array = array('i', [1,2,3,3,5]) my_array.count(3) # 2 

Преобразовать массив в строку, используя метод tounicode()

tounicode() преобразует юникод массив в строку.

my_char_array = array('u', ['g','e','e','k']) # array('u', 'geek') print(my_char_array.tounicode()) # geek 

Преобразовать массив в список Python с теми же элементами, используя метод tolist()

Когда вам нужен Python list объектов, вы можете использовать tolist() метод , чтобы преобразовать ваш массив в список.

my_array = array('i', [1,2,3,4,5]) c = my_array.tolist() # [1, 2, 3, 4, 5] 

Потренируйте самостоятельно

Поздравляем! Тепереь вы можете работать с массивами в Python.

4. Массивы в Python

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

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

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

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

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

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

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

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

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

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

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

клав_py.jpg

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

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

ram.jpg

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

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

форм.jpg

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

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

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

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
  • Словари / объекты
  • Области видимости
  • Типы и сравнение
  • Функции

Массив в 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 и какие есть методы для работы с ним. Надеемся, это руководство было вам полезно.

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

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

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