Массивы и списки в Python
Главная › База знаний › Программирование › Python › Массивы и списки в Python
Рассмотрим в уроке массивы и их виды, списки, нумерацию списков и основные методы при работе с ними.
Массивы
Мы уже рассматривали строковой тип данных. Он представляется как массив символов и обозначается как array. Массивы могут быть одномерными и многомерны.
Массивы символовПеред началом работы с массивами подключаем соответствующий модуль. Для этого введем команду:
from array import *
Создадим массив для данных типа int:
>>> a = array('i', [2, 5, 4, 0, 8])
>>> type(a)
<class 'array.array'>
>>> a
array('i', [2, 5, 4, 0, 8])Теперь обратимся к каждому из элементов данного массива. Попробуем изменить их и дополнить массив:
>>> a[2]
4
>>> a[6]
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
a[6]
IndexError: array index out of rangeКак видите, нельзя обратиться к элементу, которого нет.
Любой массив может содержать данные только одного типа, то есть нельзя использовать int
Список в Python
Список в Python похож на массив. Различие в том, что в списках можно хранить объекты различных типов данных. Размер списка не статичен и поддается изменениям.
На программном уровне переменная, определяемая как список, содержит ссылку на структуру в памяти, которая хранит ссылки на какие-либо другие объекты или структуры.
Рассмотрим на примере:
>>> a = [] >>> type(a) <class 'list'>
Теперь добавим элементы и проверим доступ к ним:
>>> a = [1,0.34,"Hello"] >>> a [1, 0.34, 'Hello'] >>> a[2] 'Hello' >>> a[0] 1 >>> a[1] 0.34
Нумерация списка в Python
Прямая и обратная нумерация
По умолчанию нумерация начинается с 0.
a = [1, 'abc', h, 0,256]
0 1 2 3
При обратной нумерации элементы считаются с конца и начинаются с -1:
a = [1, 'abc', h, 0,256]
-4 -3 -2 -1С помощью этих индексов можем обратиться к каждому элементу списка:
a[0] >>> 1 a[-2] >>> h
Срез
Срез — это некий диапазон символов, к которому мы обращаемся. При срезе вторым числом мы указываем номер символа, который не входит в диапазон:
a[0:2] #[1, 'abc'] a[-4:-2] #[1, 'abc']
Мы можем обратиться и к символам с использованием разных нумераций одновременно:
a[0:-2] #[1, 'abc']
Если мы не укажем одну из границ среза, то программа принимает за границу первый или последний символ:
a[:2] #[1, 'abc'] a[2:] #[h, 0,256]
Методы работы со списками
Рассмотрим основные методы работы со списками на примерах.
list.append(x)Добавляет в конце списка новый элемент x:
>>> a = [0,0.list.insert(i,x)1,"один"] >>> a.append(321) >>> a [0, 0.1, 'один', 321]
1,"один"]
>>> a.append(321)
>>> a
[0, 0.1, 'один', 321]Вставка элемента x на место i (нумерация начинается с нуля):
>>> a = [0,0.1,"один"] >>> a.insert(1,321) >>> a [0, 321, 0.1, 'один']
Добавляет в конец списка список L:
>>> a = [0,0.1,"один"] >>> b = ["два",3,4.1] >>> a.extend(b) >>> a [0, 0.1, 'один', 'два', 3, 4.1]list.remove(x)
Удаляет первый встреченный элемент со значением x:
>>> a = [0,0.1,"один",0] >>> a.remove(0) >>> a [0.1, 'один', 0]list.pop(i)
Возвращает элемент, размещенный по индексу i, удаляет его из списка:
>>> a = [0,0.1,"один",0] >>> a.pop(3) 0 >>> a [0, 0.1, 'один']list.count(x)
Возвращает количество элементов, равных x:
>>> a = [0,0.list.clear()1,"один",0] >>> a.count(0) 2
Очистка списка:
>>> a = [0,0.1,"один",0] >>> a [0, 0.1, 'один', 0] >>> a.clear() >>> a []
Курсы Робикс, в которых изучается этот материал.
- Программирование на Python в Minecraft
- Duckietown робот с системой Автопилота
Сохраните или поделитесь
Метки: Новые статьи
Массивы Python . Array Python
В Питоне нет структуры данных, полностью соответствующей массиву. Однако, есть списки, которые являются их надмножеством, то есть это те же массивы, но с расширенным функционалом. Эти структуры удобнее в использовании, но цена такого удобства, как всегда, производительность и потребляемые ресурсы. И массив, и список – это упорядоченные коллекции, но разница между ними заключается в том, что классический массив должен содержать элементы только одного типа, а список Python может содержать любые элементы.
Копировать Скопировано Use a different Browser
shapito_list = [1, 'qwerty', 4/3, [345, ['a', {5, 6, 7}]]]
print(shapito_list)
# Вывод:
[1, 'qwerty', 1.3333333333333333, [345, ['a', {5, 6, 7}]]]
Содержание
- Создание массива
- Многомерный массив
- Операции с массивами
- Обход массива с использованием цикла for
- Обход многомерного массива
- Добавление
- Определение размера
- Срез
- Функция pop
- Методы массива
- Модуль array
- Типы элементов массива
Создание массива
Существует несколько способ создать массив. Ниже приведены примеры как это можно сделать.
Копировать Скопировано Use a different Browser
можно_так = [1, 2, 3, 4, 5] можно_так_2 = list('итерируемый объект') а_можно_и_так = [i for i in range(5)] print('можно_так:', можно_так) print('можно_так_2:', можно_так_2) print('а_можно_и_так:', а_можно_и_так) print('можно_так[0]:', можно_так[0]) print('а_можно_и_так[3]:', а_можно_и_так[3]) # Вывод: можно_так: [1, 2, 3, 4, 5] можно_так_2: ['и', 'т', 'е', 'р', 'и', 'р', 'у', 'е', 'м', 'ы', 'й', ' ', 'о', 'б', 'ъ', 'е', 'к', 'т'] а_можно_и_так: [0, 1, 2, 3, 4] можно_так[0]: 1 а_можно_и_так[3]: 3
Важно не забывать: индексация массива начинается с нуля.
Многомерный массив
Двухмерный массив в Python можно объявить следующим образом.
Копировать Скопировано Use a different Browser
example_array = [[-1, 0, 0, 1], [2, 3, 5, 8]] print(example_array[0]) print(example_array[1]) print(example_array[0][3]) # Вывод: [-1, 0, 0, 1] [2, 3, 5, 8] 1
Точно так же мы можем определить трехмерный массив или многомерный массив в Питоне.
Копировать Скопировано Use a different Browser
example_array = [[[-1, 0], [0, 1]], [[2, 3], [5, 8]]] print(example_array[0]) print(example_array[1]) print(example_array[0][1]) print(example_array[0][1][0]) # Вывод: [[-1, 0], [0, 1]] [[2, 3], [5, 8]] [0, 1] 0
Операции с массивами
Давайте теперь рассмотрим операции, которые Пайтон позволяет выполнять над массивами.
Обход массива с использованием цикла for
Мы можем использовать цикл for для обхода элементов массива.
Копировать Скопировано Use a different Browser
example_array = [1, 2, 3]
for i in range(len(example_array)):
print(example_array[i])
# Вывод:
1
2
3
Здесь представлен подход, свойственный большинству языков программирования. В Python же есть свой, более удобный вариант.
Копировать Скопировано Use a different Browser
example_array = [1, 2, 3]
for i in example_array:
print(i)
# Вывод:
1
2
3
Обход многомерного массива
Для того чтоб получить элементы многомерного массива придётся использовать вложенные циклы.
Копировать Скопировано Use a different Browser
example_array = [[1, 2], [3, 4]] for i in example_array: for x in i: print(x) # Вывод: 1 2 3 4
Добавление
Мы можем использовать функцию insert() для вставки элемента по указанному индексу.
Элементы из указанного индекса сдвигаются вправо на одну позицию.
Копировать Скопировано Use a different Browser
example_array = [[1, 2], [3, 4]] example_array.insert(0, -1) example_array.insert(2, [-1, 13, 64]) print(example_array) # Вывод: [-1, [1, 2], [-1, 13, 64], [3, 4]]
Если вам нужно добавить элемент в конец массива, используйте функцию append().
Копировать Скопировано Use a different Browser
example_array = [[1, 2], [3, 4]] example_array.append(-1) example_array.append([-1, 13, 64]) print(example_array) # Вывод: [[1, 2], [3, 4], -1, [-1, 13, 64]]
Для того, чтоб объединить элементы двух массивов используйте метод extend.
Копировать Скопировано Use a different Browser
example_array = [1, 2, 3, 4] example_array.extend([5, 6]) print(example_array) # Вывод: [1, 2, 3, 4, 5, 6]
Определение размера
Используйте метод len() чтобы вернуть длину массива (число элементов массива).
Не стоит путать размер массива с его размерностью!
Копировать Скопировано Use a different Browser
example_array = [[1, 2], [3, 4]]
print('Размер массива:', len(example_array))
example_array.append(-1)
print('Размер массива:', len(example_array))
example_array.append([-1, 13, 64])
print('Размер массива:', len(example_array))
# Вывод:
Размер массива: 2
Размер массива: 3
Размер массива: 4
Поскольку индексация элементов начинается с нуля, длина массива всегда на единицу больше, чем индекс последнего элемента.
Копировать Скопировано Use a different Browser
example_array = [[1, 2], [3, 4]]
print('Равна ли длина массива номеру последнего элемента + 1?',
len(example_array) is (example_array.index(example_array[-1]) + 1))
example_array.append(-1)
print('Увеличили размер массива.')
print('Равна ли теперь длина массива номеру последнего элемента + 1?',
len(example_array) is (example_array. index(example_array[-1]) + 1))
# Вывод:
Равна ли длина массива номеру последнего элемента + 1? True
Увеличили размер массива.
Равна ли теперь длина массива номеру последнего элемента + 1? True
index(example_array[-1]) + 1))
# Вывод:
Равна ли длина массива номеру последнего элемента + 1? True
Увеличили размер массива.
Равна ли теперь длина массива номеру последнего элемента + 1? True
Небольшое пояснение: метод списка .index() возвращает индекс элемента, значение которого совпадает с тем, которое передали методу. Здесь мы передаём значение последнего элемента и, таким образом, получаем индекс последнего элемента. Будьте осторожны: если в списке есть повторяющиеся значения, этот приём не сработает!
Срез
Срез Python предоставляет особый способ создания массива из другого массива.
Копировать Скопировано Use a different Browser
example_array = [[1, 2], [3, 4]] print(example_array[::-1]) print(example_array[1:]) print(example_array[0][:-1]) # Вывод: [[3, 4], [1, 2]] [[3, 4]] [1]
Функция pop
В Python удалить ненужные элементы из массива можно при помощи метода pop, аргументом которого является индекс ячейки.
Как и в случае с добавлением нового элемента, метод необходимо вызвать через ранее созданный объект.
Копировать Скопировано Use a different Browser
example_array = [1, 2, 6, 3, 4] print(example_array.pop(4)) print(example_array) # Вывод: 4 [1, 2, 6, 3]
После выполнения данной операции содержимое массива сдвигается так, чтобы количество доступных ячеек памяти совпадало с текущим количеством элементов.
Методы массива
В Python есть набор встроенных методов, которые вы можете использовать при работе с list.
| Метод | Значение |
| append() | Добавляет элементы в конец списка |
| clear() | Удаляет все элементы в списке |
| copy() | Возвращает копию списка |
| count() | Возвращает число элементов с определенным значением |
| extend() | Добавляет элементы списка в конец текущего списка |
| index() | Возвращает индекс первого элемента с определенным значением |
| insert() | Добавляет элемент в определенную позицию |
| pop() | Удаляет элемент по индексу |
| remove() | Убирает элементы по значению |
| reverse() | Разворачивает порядок в списке |
| sort() | Сортирует список |
Модуль array
Если Вам всё-таки нужен именно классический массив, вы можете использовать встроенный модуль array.
Он почти не отличается от структуры list, за исключением, пожалуй, объявления.
Вот небольшая демонстрация:
Копировать Скопировано Use a different Browser
import array
example_array = array.array('i', [1, 2, 6, 3, 4]) # превый аргумент указывает на тип элементов. i означает integer
example_array.insert(0, -1)
print('После вставки:', example_array)
example_array.append(-1)
print('После добавления в конец:', example_array)
example_array.extend([5, 6])
print('После объединения со списком:', example_array)
print('Удалён элемент:', example_array.pop(4))
print('После удаления элемента:', example_array)
print('Срез:', example_array[0:4])
# Вывод:
После вставки: array('i', [-1, 1, 2, 6, 3, 4])
После добавления в конец: array('i', [-1, 1, 2, 6, 3, 4, -1])
После объединения со списком: array('i', [-1, 1, 2, 6, 3, 4, -1, 5, 6])
Удалён элемент: 3
После удаления элемента: array('i', [-1, 1, 2, 6, 4, -1, 5, 6])
Срез: array('i', [-1, 1, 2, 6])
Типы элементов массива
Элементы массива в модуле array могут быть следующих типов:
| Код типа | Тип в C | Тип в python |
| ‘b’ | signed char | int |
| ‘B’ | unsigned char | int |
| ‘h’ | signed short | int |
| ‘H’ | unsigned short | int |
| ‘i’ | signed int | int |
| ‘I’ | unsigned int | int |
| ‘l’ | signed long | int |
| ‘L’ | unsigned long | int |
| ‘q’ | signed long long | int |
| ‘Q’ | unsigned long long | int |
| ‘f’ | float | float |
| ‘d’ | double | float |
Как Вы можете видеть, со строками модуль не работает.
Что это такое и как их использовать | Linode Docs
Массивы Python обеспечивают эффективный способ хранения нескольких значений одного типа в одной переменной. В этом руководстве вы узнаете, что такое массивы Python и как их использовать, а также разницу между списками Python и массивами. Вы также узнаете, как перебирать массив, добавлять и удалять элементы из массива и как комбинировать значения, хранящиеся в разных массивах.
Что такое массивы в Python?
В Python массив — это упорядоченный набор объектов одного типа. Эти характеристики дают массивам два основных преимущества. Во-первых, элементы в массиве можно последовательно идентифицировать по их индексу или местоположению в массиве. Во-вторых, гарантируется, что элементы в массиве принадлежат к одному и тому же типу.
При создании массива в Python необходимо указать тип сохраняемых данных. Доступные типы обозначаются кодами, которые состоят из следующего:
| Код типа | Тип C | Тип Python | Мин. Байты |
|---|---|---|---|
| ‘b’ | sign char | int | 1 |
| ‘B’ | 9002 5 беззнаковых символовцелое число | 1 | |
| ‘u’ | wchar_t | Символ Юникода | 2 |
| ‘h’ | короткое со знаком | целое число | 9002 5 2|
| ‘H’ | unsigned short | int | 2 |
| ‘i’ | целое число со знаком | целое число | 2 |
| ‘I’ | целое число без знака | целое число 900 26 | 2 |
| ‘l’ | длинный знак | целое число | 4 |
| ‘L’ | unsigned long | int | 4 |
| ‘q’ | 90 025 signed long longint | 8 | |
| ‘Q’ | unsigned long long | int | 8 |
| ‘f’ | float | float | 4 |
| ‘ d’ | double | float | 8 |
Однако обычно для массивов, содержащих номера, вы можете сосредоточиться на использовании только двух из доступных кодов.
Используйте i код для массивов, содержащих целые числа. Используйте код d для массивов, содержащих числа с плавающей запятой.
Вы можете увидеть пример, показывающий, как использовать код для инициализации массива в начале раздела «Как использовать массивы в Python» этого руководства.
Массивы в Python и списки
Часто люди, говорящие о массивах в Python, на самом деле ссылаются на списки Python . Хотя списки и массивы имеют некоторое сходство в Python, это два разных типа коллекций.
Основное различие между списками и массивами заключается в том, что массивы ограничивают тип объекта, который он может хранить. Списки не дают возможности ограничить типы содержащихся в них объектов. При использовании массива вы можете быть уверены, что он содержит только тот тип, который был указан при создании.
Один список Python может одновременно хранить целые числа, строки и словари. Вы даже можете добавить в существующий список дополнительные элементы других типов.
Напротив, элементы в массиве Python могут быть только одного типа. Массив целых чисел может содержать только целые числа и к нему могут добавляться только другие целые числа.
Однако, несмотря на это различие, вы можете перемещаться по массивам и спискам и изменять их одним и тем же способом. Все операции, подробно описанные ниже для массивов, за исключением самой функции array() , можно применять и к спискам.
Как использовать массивы в Python
В следующих нескольких разделах этого руководства показано, как работать с массивами в Python. Python имеет широкий спектр операций, которые могут помочь вам эффективно использовать массивы. В разделах ниже показаны наиболее распространенные операции, которые могут потребоваться для выполнения над массивами.
Все приведенные ниже примеры работают с простым целочисленным массивом, созданным с использованием следующего кода Python:
из импорта массива *
пример_массива = массив ("i", [2, 4, 6, 8])
Примечание Модуль массива не загружается по умолчанию в Python.
Вместо этого вам нужно импортировать модуль, чтобы начать работать с массивами.
Навигация по массивам Python
Существует два способа взаимодействия с содержимым массива: либо с помощью нотации индексации Python, либо с помощью цикла. Каждый из них рассматривается в следующих разделах.
Индексы и фрагменты массива Python
Доступ к отдельным элементам массива можно получить с помощью индексов. Индексы массива начинаются с 0 . Это означает, что первому элементу массива присваивается индекс 0 , и индекс каждого последующего элемента увеличивается оттуда.
Итак, чтобы получить доступ к первому, второму и третьему элементам example_array , вы используете следующую нотацию индекса:
example_array[0]
2
пример_массива[1]
4
пример_массива[2]
6
Вы также можете использовать отрицательные числа в качестве индексов. Когда вы используете отрицательное число в качестве индекса, Python считает в массиве в обратном порядке, начиная с -1 как последнего элемента в массиве.
В следующем примере выполняется доступ к последнему значению, хранящемуся в example_array :
example_array[-1]
8
Python поддерживает более продвинутую индексацию через срез 9Обозначение 0168. Нарезка позволяет выбрать диапазон элементов из массива.
Синтаксис записи среза следующий:
[старт:стоп:шаг]
start определяет первый индекс диапазона, stop определяет последний. Часть шага является необязательной. Он используется для определения того, сколько элементов нужно пройти при перемещении по диапазону start и stop диапазону. По умолчанию значение установлено это 1 .
Следующий пример нарезает диапазон от индекса 0 до индекса 3 . Он проходит через этот диапазон, используя 2 шагов за раз, то есть пропускает все остальные элементы:
example_array[0:3:2]
array('i', [2, 6]) Нотация среза Python — это мощный инструмент, который можно использовать для выполнения гораздо более сложных операций, чем показано в этом руководстве.
Чтобы увидеть больше примеров с подробными объяснениями, ознакомьтесь с нашими руководствами «Как нарезать и индексировать строки в Python и списках Python и как их использовать». Хотя эти руководства не имеют прямого отношения к массивам Python, концепции применимы в равной степени.
Перебор элементов массива
Массивы Python можно перебирать, используя для циклов. Это обеспечивает удобный способ выполнения действия над каждым элементом массива. Каждый цикл дает переменную — item в примере — соответствующую элементу в массиве:
для элемента в example_array:
печать (элемент)
Вывод возвращает значение каждого элемента массива.
2 4 6 8
Используя функцию enumerate , вы одновременно перебираете элементы и их индексы:
для i, элемент в перечислении (test_array):
print(str(i + 1) + ": " + str(item))
Функция enumerate() возвращает счетчик текущей итерации (хранится в переменной i ) и значение текущей итерации (хранится в переменной item ).
Поскольку индексы массива начинаются с 0 , инструкция внутри цикла добавляет 1 к значению счетчика i для вычисления текущего индекса.
1:2 2:4 3:6 4:8
Вывод возвращает порядковый номер текущего элемента в массиве вместе с самим значением. Индекс и значение разделены : , как указано в операторе печати функции enumerate() .
Изменение массивов Python
Python также предоставляет способы изменения содержимого массива, независимо от того, нужно ли вам добавлять элементы или удалять их. Есть даже способ объединить несколько массивов. В следующих разделах показано, как выполнять все эти операции, работая с тем же массивом примеров, что и выше.
Добавление элемента в массив
Массивы Python включают два встроенных метода для добавления новых элементов. Какой метод вы используете, зависит от того, где в массиве вы хотите добавить новый элемент.
Используйте метод append() для добавления нового элемента в конец массива.
Пример ниже добавляет целое число 10 в качестве нового элемента в конце example_array :
example_array.append(10) печать (пример_массива)
Массив example_array теперь также содержит целое число 10 .
array('i', [2, 4, 6, 8, 10]) Используйте метод insert() для добавления нового элемента в определенную позицию в массиве. Метод принимает два параметра; первый параметр — это индекс, в который должен быть вставлен элемент, а второй — элемент, который нужно вставить в массив.
В приведенном ниже примере используется метод insert() для помещения целого числа 7 в 9.0157 пример_массива позиция индекса 3 .
пример_массива.вставка(3, 7) печать (пример_массива)
Печать массива подтверждает, что теперь он содержит целое число 7 в позиции индекса 3 :
array('i', [2, 4, 6, 7, 8, 10]) Удаление элемента из Массив
Массивы Python включают два встроенных метода, которые можно использовать для удаления элементов из массива.
Выбранный вами метод зависит от того, хотите ли вы удалить элемент на основе заданного значения или заданного индекса.
Метод remove() принимает в качестве параметра значение, которое нужно удалить из массива. В следующем примере метод remove() удаляет целое число 7 из example_array . Это целое число было добавлено в массив в предыдущем разделе.
пример_массива.удалить(7) печать (пример_массива)
Вывод подтверждает, что example_array больше не содержит 7 .
массив('i', [2, 4, 6, 8, 10]) С другой стороны, метод pop() можно использовать для удаления элементов на основе индекса. В следующем примере используется индекс -1 для удаления последнего элемента массива, который был одним из элементов, добавленных в предыдущем разделе:
example_array.pop(-1) печать (пример_массива)
10
array('i', [2, 4, 6, 8]) Метод pop() возвращает значение удаленного элемента.
Вот почему на выходе отображается целое число 10 9.0158 . Это полезно, если, например, вы хотите сохранить значение удаленного элемента в новой переменной.
Объединение массивов
Массивы Python можно объединять или объединять с помощью оператора + . Есть и другие способы объединения массивов — например, с помощью цикла. Но оператор + предоставляет наиболее удобный метод, если ваша цель — просто соединить два или более массивов.
В приведенном ниже примере example_array объединяется с новым массивом other_array и хранится в Combined_Array .
пример_массива = массив ("i", [2, 4, 6, 8])
другой_массив = массив ("i", [20, 40, 60, 80])
комбинированный_массив = примерный_массив + другой_массив
печать (объединенный_массив)
Печать comb_array подтверждает, что теперь он содержит все значения, хранящиеся в двух объединенных массивах.
array('i', [2, 4, 6, 8, 20, 40, 60, 80]) Заключение
Массивы Python — это тип коллекции, который может хранить несколько значений.
К каждому значению можно получить доступ, используя нотацию индекса. Хотя массив Python похож на список, он отличается тем, что в массиве можно хранить значения только одного типа. Массивы также имеют встроенные методы, помогающие добавлять и удалять элементы. Вы также можете объединить два массива, используя + оператор.
Вы можете обратиться к следующим ресурсам для получения дополнительной информации на эту тему. Хотя они предоставляются в надежде, что они будут полезно, обратите внимание, что мы не можем ручаться за точность или своевременность материалы внешнего размещения.
- Документы Python: массив — эффективные массивы числовых значений
Массив Python — определить, создать
Что такое массив Python?
A Python Array представляет собой набор общих типов структур данных, имеющих элементы с одинаковым типом данных. Он используется для хранения коллекций данных. В программировании на Python массивы обрабатываются модулем «array».
Если вы создаете массивы с помощью модуля массива, элементы массива должны быть одного и того же числового типа.
Когда использовать массив в Python?
Массивы Python используются, когда вам нужно использовать много переменных одного типа. Его также можно использовать для хранения набора данных. Массивы особенно полезны, когда вам нужно динамически обрабатывать данные. Массивы Python намного быстрее списка, поскольку они используют меньше памяти.
Синтаксис для создания массива в Python
Вы можете объявить массив в Python при его инициализации, используя следующий синтаксис.
имя_массива = массив.массив(код типа для типа данных, [массив,элементы])
На следующем рисунке поясняется синтаксис.
- Идентификатор : укажите имя, как обычно, для переменных
- Модуль : Python имеет специальный модуль для создания массива в Python, называемый «массивом» — вы должны импортировать его перед использованием
- Метод : модуль массива имеет метод для инициализации массива. Он принимает два аргумента, код типа и элементы. 904:30
- Код типа : укажите тип данных, используя доступные коды типов (см. список ниже)
- Элементы : укажите элементы массива в квадратных скобках, например [130,450,103]
Он принимает два аргумента, код типа и элементы. 904:30Как создавать массивы в Python?
В Python мы используем следующий синтаксис для создания массивов:
Класс array.array(type code[initializer])
Например
импортировать массив как myarray
abc = myarray.array('d', [2.5, 4.9, 6.7]) Приведенный выше код создает массив целочисленного типа. Буква «д» — это код типа.
В следующих таблицах показаны коды типов:
| Код типа | Питон типа | С Тип | Минимальный размер (байты) |
|---|---|---|---|
| ‘у’ | Символ Юникода | Py_UNICODE | 2 |
| ‘б’ | Интервал | Подписанный символ | 1 |
| «Б» | Интервал | Символ без знака | 1 |
| ‘ч’ | Интервал | Короткая подпись | 2 |
| «л» | Интервал | Длинная подпись | 4 |
| L | Интервал | Длинный без знака | 4 |
| «к» | Интервал | Подпись длинная длинная | 8 |
| «К» | Интервал | Длинный без знака длинный | 8 |
| ‘Н’ | Интервал | Беззнаковый короткий | 2 |
| ‘ф’ | Поплавок | Поплавок | 4 |
| ‘д’ | Поплавок | Двойной | 8 |
| «и» | Интервал | Подпись | 2 |
| «Я» | Интервал | Целое число без знака | 2 |
Как получить доступ к элементам массива?
Вы можете получить доступ к любому элементу массива, используя его индекс.
Синтаксис:
имя_массива[номер_индекса]
Например,
массив импорта
баланс = массив.массив('i', [300,200,100])
print(balance[1]) Вывод:
200
На следующем рисунке показана основная концепция доступа к элементам массива по их индексу.
Здесь мы получили доступ ко второму значению массива, используя его индекс, который равен 1. Результатом этого будет 200, что в основном является вторым значением сбалансированного массива.
Индекс массива начинается с 0. Вы также можете получить доступ к последнему элементу массива, используя индекс -1.
Пример:
импортировать массив как myarray
abc = myarray.array('d', [2.5, 4.9, 6.7])
print("Первый элемент массива:",abc[0])
print("Последний элемент массива:",abc[-1]) Вывод:
Первый элемент массива: 2.5 Последний элемент массива: 6.
7 Вы также можете получить доступ к элементам с помощью оператора «:», как показано в приведенных ниже примерах массивов Python.
Пример:
импортировать массив как myarray
abc= моймассив.массив('q',[3,9,6,5,20,13,19,22,30,25])
печать (abc [1: 4])
print(abc[7:10]) Вывод:
массив('q', [9, 6, 5])
array('q', [22, 30, 25]) Эта операция называется операцией нарезки .
Как вставлять элементы?
Операция вставки массива Python позволяет вам вставлять один или несколько элементов в массив в начале, конце или любом заданном индексе массива. Этот метод ожидает два аргумента index и value.
Синтаксис:
имя_массива.вставка(индекс, значение)
Пример:
Добавим новое значение сразу после второго элемента массива. В настоящее время в нашем массиве баланса есть три элемента 300, 200 и 100. Рассмотрим второй элемент массива со значением 200 и индексом 1.
Чтобы вставить новое значение сразу «после» индекса 1, вам нужно сослаться на индекс 2 в вашем методе вставки, как показано в приведенном ниже примере массива Python:
import array
баланс = массив.массив('i', [300,200,100])
balance.insert(2, 150)
печать(баланс) Вывод:
массив('i', [300,200,150,100]) Пример 2:
импортировать массив как myarr
a=myarr.массив('b',[2,4,6,8,10,12,14,16,18,20])
а. вставить (2,56)
print(a) Вывод:
array('b', [2, 4, 56, 6, 8, 10, 12, 14, 16, 18, 20]) Как изменить элементы?
Массивы в Python изменяемы. Их можно изменить с помощью следующего синтаксиса:
Имя_объекта[индекс]=значение;
Пример:
импортировать массив как myarr
a=myarr.массив('b',[3,6,4,8,10,12,14,16,18,20])
а[0]=99
print(a) Вывод:
array('b', [99, 6, 4, 8, 10, 12, 14, 16, 18, 20]) Мы также можем выполнять операции конкатенации массивов в Питоне.
Пример:
импортировать массив как myarr
первый = myarr.array('b', [4, 6, 8])
второй = myarr.array('b', [9, 12, 15])
числа = myarr.array('b')
числа = первое + второе
печать(числа) Выходные данные:
array('b', [4, 6, 8, 9, 12, 15]) Приведенный выше пример кода массива Python объединяет две переменные, называемые «first» и «second». Результат сохраняется в переменной с именем «число».
Последняя строка кода используется для печати двух массивов.
Как извлечь элемент из массива в Python?
В Python разработчик может использовать метод pop() для извлечения элемента из массива Python. Ниже приведен пример метода pop() в Python.
Массив Python pop Пример:
импортировать массив как myarr
первый = myarr.array('b', [20, 25, 30])
первый.поп(2)
print(first) Вывод:
array('b', [20, 25]) Вы также можете использовать оператор Python del.
Пример
импортировать массив как myarr
нет = myarr.array('b', [10, 4, 5, 5, 7])
дель нет[4]
print(no) Вывод:
array('b', [10, 4, 5, 5]) Как удалить элементы?
С помощью этой операции вы можете удалить один элемент из массива по значению. Этот метод принимает только один аргумент, значение. После запуска этого метода элементы массива переупорядочиваются, а индексы переназначаются.
Синтаксис:
arrayName.remove(value)
Пример:
Удалим значение «3» из массива
импортируем массив как myarray
сначала = myarray.array('b', [2, 3, 4])
первый.удалить(3)
печать (первая) Вывод:
массив('b', [2, 4]) Как найти и получить индекс значения в массиве
С помощью этой операции вы можете искать элемент в массиве на основе на его стоимости. Этот метод принимает только один аргумент, значение.
Это неразрушающий метод, то есть он не влияет на значения массива.
Синтаксис:
имя_массива.индекс(значение)
Пример:
Давайте найдем значение «3» в массиве. Этот метод возвращает индекс искомого значения.
импортировать массив как myarray
число = моймассив.массив('b', [2, 3, 4, 5, 6])
print(number.index(3)) Вывод:
1
Эта операция вернет индекс первого вхождения упомянутого элемента.
Как реверсировать массив в Python
Эта операция реверсирует весь массив.
Синтаксис: array.reverse()
импортировать массив как myarray
число = моймассив.массив('b', [1,2, 3])
номер.обратный()
печать (число) Вывод:
array('b', [3, 2, 1]) Преобразование массива в Unicode:
Массив Python можно преобразовать в Unicode. Чтобы удовлетворить эту потребность, массив должен быть типа «u»; в противном случае вы получите «ValueError».
Пример:
из массива импорта массива
р = массив ('и',[и'\u0050',и'\и0059',и'\и0054',и'\и0048',и'\и004F',и'\и004E'])
печать (р)
q = p.tounicode()
print(q) Вывод:
массив('u', 'PYTHON')
ПИТОН Подсчет появления значения в массиве
Вы также можете подсчитать количество вхождений элементов в массиве, используя синтаксис array.count(x).
Пример:
импортировать массив как myarr
число = myarr.array('b', [2, 3, 5, 4,3,3,3])
print(number.count(3)) Вывод:
4
Обход массива
Вы можете перемещаться по массиву Python с помощью циклов, подобных этому:
import array
баланс = массив.массив('i', [300,200,100])
для x в балансе:
напечатать (х) Выход:
200 300 100
Резюме:
- Массив — это распространенный тип структуры данных, в котором все элементы должны быть одного типа данных.
