Как изменить размер массива python

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

Изменение размерности массивов

Предположим, у
нас имеется массив, состоящий из десяти чисел:

a = np.arange(10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

a.shape = 2, 5   # массив размерностью 2x5

В результате
изменится представление массива, на которое ссылается переменная a. Если же
требуется создать новое представление массива, сохранив прежнее, то следует
воспользоваться методом reshape():

b = a.reshape(10)  # массив [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

И, как мы с вами
говорили на предыдущем занятии, ссылки b и a будут использовать
одни и те же данные, то есть, изменение массива через b:

приведет к
изменению соответствующего элемента массива a:

array([[-1,  1,  2,  3,  4],

       [ 5,  6, 
7,  8,  9]])

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

приведет к
ошибке, т.к. размерность 3×3 = 9 элементов, а в массиве 10
элементов. Здесь всегда должно выполняться равенство:

n1 x n2 x … x nN = число
элементов массива

Но допускается
делать так:

a.shape = -1, 2  # размерность 5x2

Отрицательное
значение -1 означает автоматическое вычисление размерности по первой оси. По
второй берется значение 2. В этом случае получим размерность 5×2.

То же самое
можно делать и в методе reshape():

b.reshape(-1, 1) # размерность 10x1
b.reshape(1, -1) # размерность 1x10

Обратите
внимание, в последних двух случаях мы получаем представления двумерных
массивов, преобразуя одномерный. Это важный момент, так как на выходе метода reshape() получается
матрица с двумя осями (строки и столбцы), тогда как изначально массив b имел только
одну ось. Не случайно последнее представление отображается с двумя квадратными
скобками:

array([[-1,  1,  2, 
3,  4,  5,  6,  7,  8,  9]])

Первая скобка –
это первая ось (строка), а вторая скобка (вторая ось) описывает столбцы. Одномерный
же массив b отображается с
одной квадратной скобкой:

array([-1,  1, 
2,  3,  4,  5,  6,  7,  8,  9])

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

b.reshape(2, -1)  # размерность 2x5
b.reshape(-1, 2)  # размерность 5x2

Первое
представление (2×5) отображается следующим образом:

array([[-1, 
1,  2,  3,  4],

       [ 5,  6, 
7,  8,  9]])

Здесь снова мы
видим две квадратные скобки (значит, массив двумерный). Первая описывает ось axis0, отвечающую за
строки, а вложенные скобки описывают вторую ось axis1, отвечающую за
столбцы.

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

c = b.ravel() # с ссылается на одномерное представление массива

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

Помимо свойства shape можно
использовать метод resize, который выполняет подобную операцию с
текущим массивом. Например:

a.resize(2, 5) # массив 2x5

Но, как мы уже
говорили, вот такая строчка приведет к ошибке:

a.resize(3, 3)  # ошибка: 3x3 != 10

Однако, мы
все-таки можем выполнить такую операцию, указав дополнительно флаг refcheck=False:

a.resize(3, 3, refcheck=False)  # массив 3x3

или так:

a.resize(4, 5, refcheck=False) # массив 4x5

В первом случае
происходит удаление одного 10-го элемента, а во втором случае – добавление
4∙5 — 3∙3 = 11 нулей. Это очень удобно, когда нам нужно менять не
только форму, но и размер самого массива.

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

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

a = np.array([(1, 2, 3), (1, 4, 9), (1, 8, 27)])

то операция
транспонирования может быть реализована так:

Обратите
внимание, мы здесь создаем лишь новое представление тех же самых данных массива
a. И изменение
элементов в массиве b:

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

Транспонирование
векторов работает несколько иначе. Предположим, имеется одномерный массив:

и мы выполняем
операцию транспонирования:

В результате
ничего не изменилось: вектор как был строкой, так строкой и остался. Почему?
Дело в том, что массив x имеет только
одну размерность, поэтому здесь нет понятия строк и столбцов. Соответственно,
операция транспонирования ни к чему не приводит. Чтобы получить ожидаемый
эффект, нужно добавить к массиву еще одну ось, например, так:

И теперь, при
транспонировании получим вектор-столбец:

Добавление и удаление осей

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

• np.expand_dims(a,
  axis) – добавление
  новой оси;

• np.squeeze(a[, axis]) – удаление
  оси (без удаления элементов).

Давайте
предположим, что у нас имеется некий многомерный массив:

x_test = np.arange(32).reshape(8, 2, 2) # массив 8x2x2

И нам
потребовалось добавить еще одно измерение (ось), причем, в самое начало, то
есть, ось axis0. Сейчас на
этой оси 8 элементов – матриц 2×2, но мы хотим сделать четырехмерный
массив, сохранив остальные три оси и их данные без изменений. Как раз это
достаточно просто сделать с помощью функции expand_dims, следующим
образом:

x_test4 = np.expand_dims(x_test, axis=0)

Обращаясь к
свойству shape:

x_test4.shape # (1, 8, 2, 2)

Видим, что
массив стал четырехмерным и первая добавленная ось axis0 содержит один
элемент – трехмерный массив 8x2x2. При
необходимости, мы всегда можем добавить новый элемент на эту ось:

a = np.append(x_test4, x_test4, axis=0) # размерность (2, 8, 2, 2)

или удалить
ненужные элементы:

b = np.delete(a, 0, axis=0) # размерность (1, 8, 2, 2)

Здесь второй
параметр 0 – индекс удаляемого элемента на оси axis0.

Если нам нужно
добавить последнюю ось в массиве, то для этого можно записать такую команду:

b = np.expand_dims(x_test4, axis=-1) # размерность (1, 8, 2, 2, 1)

Отрицательный
индекс -1 – это следующая с конца ось. Если указать индекс -2, то добавится
предпоследняя ось и так далее. Отрицательные индексы очень удобно использовать
при работе с массивами произвольных размерностей.

Следующая
функция squeeze позволяет
удалить все оси с одним элементом. Например, строчка:

c = np.squeeze(b) # размерность (8, 2, 2)

превращает
массив размерностью (1, 8, 2, 2) в массив размерностью (8, 2, 2). При
необходимости, дополнительно мы можем самостоятельно указать оси, которые
следует удалять, например, так:

c = np.squeeze(b, axis=0) # удалит только ось axis0, не затронув другие

Но, если указать
ось с числом элементов больше 1, то возникнет ошибка:

c = np.squeeze(b, axis=1) # ошибка, на оси axis1 8 элементов

Объект newaxis

В NumPy добавлять новые
оси иногда удобнее с помощью специального объекта np.newaxis. Например,
пусть у нас есть одномерный массив:

a = np.arange(1, 10) # array([1, 2, 3, 4, 5, 6, 7, 8, 9])

У него одна ось
– одно измерение. Добавим еще одну ось, допустим, в начало. С помощью объекта np.newaxis это можно
сделать так:

b = a[np.newaxis, :] # добавление оси axis0
b.shape # (1, 9)

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

c = a[np.newaxis, :, np.newaxis]
c.shape # (1, 9, 1)

Как видите, это
достаточно удобная операция.

Часто разработчикам приходится изменять размеры массивов. Например, переформатировать исходные данные, чтобы разделить их на подмассивы. В некоторых случаях требуется еще и объединять многомерные данные в единый массив значений. Чтобы решать такие задачи, массивы numpy.ndarray предоставляют набор методов, самым популярным из которых является метод reshape().

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

Как изменить размер массива

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

1. Узнаем размер массива и индексы вдоль оси
2. Изменим размер массива

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

Как узнать размер массива и индексы вдоль оси

Чтобы изменить размер numpy.ndarray, нужно узнать его значение. Для этого используют атрибут shape:

import numpy as np

one_dimension_array = np.array(
    [0,1,2,3,4,5,6,7,8,9,10,11]
)

print(one_dimension_array.shape)
# => (12,)

two_dimensions_array = np.array(
    [
        [0,1,2],
        [3,4,5],
        [6,7,8],
        [9,10,11]
    ]
)
print(two_dimensions_array.shape)
# => (4, 3)

three_dimensions_array = np.array(
    [
        [
            [0,1],
            [2,3],
        ],
        [
            [4,5],
            [6,7],
        ],
        [
            [8,9],
            [10,11]
        ]
    ]
)
print(three_dimensions_array.shape)
# => (3, 2, 2)

В примере выше атрибут shape возвращает кортеж целых чисел. Длина кортежа указывает на размерность массива:

• (12,) — одномерный массив
• (4, 3) — двумерный массив
• (3, 2, 2) — трехмерный массив

Числа в кортеже означают количество элементов по конкретной оси индексов:

• (12,) — 12 значений
• (4, 3) — четыре блока значений по три значения в каждом
• (3, 2, 2) — три блока значений, каждый из которых состоит из двух блоков по два значения

Название ось индексов отсылает к декартовой системе координат. Вспомним ее основные правила:

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

Теперь, когда мы знаем размер исходного массива, можно изменять его форму. Для этого используем метод reshape().

Как изменить размер массива с помощью метода reshape()

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

Попробуем получить двумерный массив two_dimensions_array из одномерного массива one_dimension_array. Для этого используем метод reshape() с новым размером данных (4, 3):

print(one_dimension_array.reshape(((4, 3))))
# => [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]

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

print(one_dimension_array.reshape((3, 2, 2)))
# => [[[ 0  1]
#   [ 2  3]]
#  [[ 4  5]
#   [ 6  7]]
#  [[ 8  9]
#   [10 11]]]

Изменять форму массива можно не только от данных меньшей размерности к данным большей размерности. Это можно делать и в обратную сторону.

Попробуем получить исходный одномерный массив one_dimension_array из двумерного массива two_dimensions_array:

print(two_dimensions_array.reshape((12,)))
# => [ 0  1  2  3  4  5  6  7  8  9 10 11]

А тут переформатируем three_dimensions_array в two_dimensions_array:

print(three_dimensions_array.reshape((4,3)))
# => [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]

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

print(three_dimensions_array.reshape((12,)))
# => [ 0  1  2  3  4  5  6  7  8  9 10 11]

С помощью атрибута shape можно узнать размерность массива numpy.ndarray. А метод reshape поможет ее уменьшить или увеличить. Однако у этого массива есть ограничения по размеру данных — его нужно соблюдать, чтобы оптимизировать выполнения методов над массивами.

Какие размеры массива допустимы

У массива numpy.ndarray есть ограничения по размеру данных — по осям индексов должны быть данные одного размера. Это ограничение позволяет оптимизировать выполнения методов над массивами. Рассмотрим на примере.

Допустим, нам нужно сконвертировать список из списков длиной три и два:

np.array(
    [
        [0,1,2],
        [3,4,],
    ]
)
# => [list([0, 1, 2]) list([3, 4])]

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

Попробуем найти в данном массиве максимальный элемент 4. Это приведет к такому результату:

print(np.array(
    [
        [0,1,2],
        [3,4,],
    ]
).max())
# => [3, 4]

В этом примере мы получили не тот результат, которого ожидали.

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

В случае с методом reshape() Numpy вообще не дает совершить некорректную конвертацию массива из 12 элементов в массив из 15 элементов — три блока по пять значений. В этом случае он вызывает исключение:

one_dimension_array.reshape(3,5)
# => ValueError: cannot reshape array of size 12 into shape (3,5)

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

Как сделать автоматический расчет размера массива

Ограничения на размер массива позволяют не указывать некоторые размеры в методе reshape(). Это можно оставить на автоматический расчет. Для этого нужное значение размерности поменяем на -1:

print(one_dimension_array.reshape((4,3)))
print(one_dimension_array.reshape(((4, -1))))
print(one_dimension_array.reshape(((-1, 3))))
# => [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]

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

Для массивов большей размерности это работает по такому же принципу:

print(one_dimension_array.reshape((3, 2, 2)))
print(one_dimension_array.reshape((-1, 2, 2)))
print(one_dimension_array.reshape((3, -1, 2)))
print(one_dimension_array.reshape((3, 2, -1)))
# => [[[ 0  1]
#   [ 2  3]]
#  [[ 4  5]
#   [ 6  7]]
#  [[ 8  9]
#   [10 11]]]

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

print(three_dimensions_array.reshape((12,)))
print(three_dimensions_array.reshape((-1,)))
# => [ 0  1  2  3  4  5  6  7  8  9 10 11]

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

Как размер массива меняется на практике

Изменение формы массива помогает подготовить исходные данные — после такой обработки их будет удобнее анализировать и преобразовывать.

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

orders = [7, 1, 7, 8, 4, 2, 4, 5, 3, 5, 2, 3, 8, 12, 8, 7, 15, 11, 13, 9, 21, 18, 17, 21, 25, 16, 25, 17,]
shops_number = 4

orders_matrix = np.array(orders)
orders_matrix = orders_matrix.reshape(-1, shops_number)
print(orders_matrix)
# => [[ 7  1  7  8]
#  [ 4  2  4  5]
#  [ 3  5  2  3]
#  [ 8 12  8  7]
#  [15 11 13  9]
#  [21 18 17 21]
#  [25 16 25 17]]

print(orders_matrix.shape)
# => (7, 4)

Полученный массив данных можно визуализировать в виде такой таблицы:

Выводы

Метод shape — важный атрибут для структурного описания массива numpy.ndarray. Он помогает узнать размер вдоль каждой оси.

В Python нет встроенного типа «массив», но вместо него можно использовать встроенный тип «список» (list). Также при использовании библиотеки NumPy можно создавать объект типа «массив» (Ndarray). Далее о каждом из этих двух вариантов подробнее.

Списки (list)

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

Создание

• Создание пустого списка:

names = []

names = list()

• Создание списка с элементами:

names = ['Иван', 'Женя', 'Ольга']

• Создание списка на основе другого списка:

names = ['Иван', 'Женя', 'Ольга']
new_names = list(names)

• Создание списка повторением какого-либо элемента или другого списка:

names = ['Иван', 'Женя', 'Ольга']
new_names = names * 2

• Создание списка с помощью конструкции range():

numbers = list(range(10))

Функция range(10) возвращает числа от 0 до 9, на основе которых создаётся новый список.

Обращение к элементу

Обращение к элементу списка производится по индексу элемента:

names[0]

Индексы элементов начинаются с нулевого, то есть первый элемент списка имеет индекс «0», а второй — «1».

Обход элементов

Элементы списка можно обходить циклами for и while:

for name in names:
    print(name)

Сравнение

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

list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list2 = list(range(10))

Размерность

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

names = [['Иван', 19],
        ['Женя', 20],
        ['Ольга', 21]]

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

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

names = [['Иван', 19],
        ['Женя', 20],
        ['Ольга', 21]]
names[1][0]

Преобразование

Двумерный список можно преобразовать в словарь с парами «ключ-значение»:

names = [['Иван', 19],
        ['Женя', 20],
        ['Ольга', 21]]
new_dict = dict(names)

Матрицы

Двумерный список является матрицей, которую визуально можно представить в следующем виде:

В данном примере переменная А содержит двумерный список, т.е. список списков, каждый из которых состоит из трёх элементов. Тип list в Python не поддерживает работу со списками как с матрицами, но, тем не менее, позволяет матрицы хранить.

Массивы NumPy (Ndarray)

Создание

Для использования класса Ndarray предварительно необходимо импортировать библиотеку numpy:

import numpy as np

Для создания массива используется функция модуля numpy — array():

import numpy as np

new_array = np.array(['Иван', 'Женя', 'Ольга'])

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

import numpy as np

new_array = np.array([['Иван', 19],
                        ['Женя', 20],
                        ['Ольга', 21]])

Тип значения элементов

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

import numpy as np

new_array = np.array([['Иван', 19],
                        ['Женя', 20],
                        ['Ольга', 21]], dtype=np.str)

Обращение к элементам

Обращение к элементам массива Ndarray производится аналогично получение элемента в многомерном списке.

Атрибуты класса Ndarray

Далее рассмотрим атрибуты класса Ndarray:

• ndim — число измерений (осей) массива;
• shape — размерность массива. Это tuple, содержащий натуральные числа (n, m) — длины массива по каждой оси (n — высота, m — ширина). Число элементов кортежа shape равно ndim.
• size — количество элементов в массиве, равно произведению всех элементов атрибута shape;
• dtype — тип элементов массива. NumPy предоставляет возможность использовать как встроенные типы, например: bool_, character, int8, int16, int32, int64, float8, float16, float32, float64, complex64, object_, так и собственные типы данных, в том числе и составные;
• itemsize — размер каждого элемента массива в байтах;
• data — буфер, содержащий фактические элементы массива. Обычно не нужно использовать этот атрибут, так как обращаться к элементам массива проще всего с помощью индексов.

Изменение размерности

Размерность массива darray в Python можно изменять методом reshape():

import numpy as np

new_array = np.array([['Иван', 19],
                        ['Женя', 20],
                        ['Ольга', 21]], dtype=np.str)
new_array.reshape(2, 3)

При этом количество элементов должно позволять это сделать, т.е. произведение элементов атрибута shape до и после изменения размера должно быть одинаковым. К примеру, нельзя изменить размерность массива с (3, 4) на (2, 5), но можно изменить её на (2, 6).

Массивы в Python.

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

Работа с массивами с заданным размером  в Python

Объявление массива в Python известного размера
Массив с определенным числом элементов N  в Python объявляется так, при этом всем элементам массива присваивается нулевое значение
Название массива = [0]*N
Задание значений элементов массива в python.
Задать значение элементов массива можно при объявлении массива. Это делается так
Название массива = [элемент №1, элемент №2, элемент №3,…]
Название массива[индекс элемента массива] = значение элемента
При этом массив будет иметь фиксированный размер согласно количеству элементов.
Пример. Задание значений элементов массива в Python двумя способами.
Способ №1.
a = [0, 1, 2, 3, 4]
Способ №2.
a[0] = 0
a[1] = 1
a[2] = 2
a[3] = 3
a[4] = 4
Таблица основных типов данных в Python. 

При работе с массивами удобно использовать цикл for для перебора всех элементов массива.
a = [0] * размер массива
for i in range(размер массива):
    a[i] = выражение

Размер массива в Питон можно узнать с помощью команды len(имя массива)
Пример программы на Python, которая вводит массив с клавиатуры, обрабатывает элементы и выводит на экран измененный массив С клавиатуры вводятся все элементы массива, значения элементов увеличиваются в два раза. Выводим все значения элементов в консоль. Чтобы элементы массива выводились в одну строку через пробел, используем параметр end =» » в операторе вывода на экран print(a[i], end = » «)
a = [0] * 4
for i in range(len(a)):
    i = str(i + 1)
    print(«Введите элемент массива » + i, end = » «)
    i = int(i)
    i = i — 1
    a[i] = int(input())
print(«»)
for i in range(len(a)):
    a[i] = a[i] * 2
for i in range(len(a)):
    print(a[i], end = » «)
Алгоритм поиска минимального значения массива в python
Нужно перебрать все элементы массива и каждый элемент сравнить с текущим минимумом. Если текущий элемент меньше текущего минимума, то этот элемент становится текущим минимумом.
Алгоритм поиска максимального значения массива в python.
Аналогично, для поиска максимального значения нужно перебрать и сравнить каждый элемент с текущим максимумом. Если текущий элемент больше текущего максимума, то текущий максимум приравнивается к этому элементу.
Пример. Программа запрашивает значения элементов массива и выводит минимальное и максимальное значения на экран.
a = [0] * 9
for i in range(len(a) — 1):
    i = str(i + 1)
    print(«Введите элемент массива » + i, end = » «)
    i = int(i)
    a[i] = int(input())

   
min = a[0]
max = a[0]

for i in range(len(a)):
    if (a[i ]< min):
        min = a[i]   
    if (a[i] > max):
        max = a[i]        
min = str(min)
max = str(max)

print(«Минимальное значение = » + min)
print(«Максимальное значение = » + max)

Работа с массивами с изменяемым размером в python

Как правило в программах Python размер массива не четко задан, может вводиться с клавиатуры, может изменяться и размер массива, элементы могут добавляться и удаляться.
Для работы с массивами изменяемого размера в Python используется специальное объявление массива 
Объявление  массива с неизвестным числом элементов в python
Имя массива=[]
Задание массива явно
Имя массива=[значение первого элемента, значение второго,….]
Вывод всего массива в python
print(имя массива)
Например
a=[]
a=[10,2,3]
print(a)
[10, 2, 3]
Добавление элемента в конец массива вpython
Имя массива.append(значение)
Например
a=[]
a=[10,2,3]
print(a)
a.append(7)
print(a)
будет выведено на экран
[10, 2, 3]
[10, 2, 3, 7]
Ввод массива с клавиатуры в python
Для ввода массива с неизвестным числом элементов в python в программе запрашивается чилсо элементов, а затем в цикле for добавляется элементы с помощью команды имямассива.append()
a=[]
n=int(input())
for i in range(n):
    a.append(int(input()))
print(a)
Для определения длины массива в python используется команда len(имя массива)
Вывод поэлементно массива на экран в Python
Вывод массива неизвестной длины осуществляется в цикле for, верхняя граница цикла определятся с помощью команды len(имя массива)
for i in range(len(a)):
    print(a[i])
Для удаления элемента массива в python используется команда
Имя массива.remove(номер элемента который нужно удалить)
Например
a=[]
a=[1,2,3]
print(a)
a.remove(1)
print(a)
выведет на экран
[1, 2, 3]
[2, 3]
Сортировка массива в python
Для сортировки числового массива по возрастанию в python используется команда
имя массива.sort()

Пример программы на Python ввода массива, вывода массива и сортировки массива
a=[]
n=int(input())
for i in range(n):
    a.append(int(input()))
print(‘массив’)
for i in range(len(a)):
    print(a[i])
a.sort()
print(‘отсортированный массив’)
for i in range(len(a)):
    print(a[i])

Вернуться к содержанию Следующая тема Работа с модулями в Питон 

Полезно почитать по теме массивы в python:
Матрицы в pyhton
Работа с матрицами в python в библиотеке numpy

Игра на python камень ножницы бумага с анализом вариантов, пример эффективного использования массивов

Решение задач егэ по информатике на массивы

Поделиться: