Задание 1.

1. А) Дан одномерный массив, состоящий из N целочисленных элементов.

Ввести массив с клавиатуры. Найти максимальный элемент. Вывести
массив на экран в обратном порядке.
Б) В массиве действительных чисел все нулевые элементы заменить на
среднее арифметическое всех элементов массива.
2. А) Дан одномерный массив, состоящий из N целочисленных элементов.
Ввести массив с клавиатуры. Найти минимальный элемент. Вывести
индекс минимального элемента на экран.
Б) Дан массив целых чисел. Переписать все положительные элементы
во второй массив, а остальные - в третий.
3. А) Дан массив целых чисел. Найти максимальный элемент массива и
его порядковый номер.
Б) Дан одномерный массив целого типа. Получить другой массив,
состоящий только из нечетных чисел исходного массива или сообщить, что
таких чисел нет. Полученный массив вывести в порядке убывания элементов.
4. А) Дан одномерный массив из 10 целых чисел. Вывести пары
отрицательных чисел, стоящих рядом.
б) Дан целочисленный массив размера 10. Создать новый массив,
удалив все одинаковые элементы, оставив их 1 раз.
5. А) Дан массив целых чисел. Найти сумму элементов с четными
номерами и произведение элементов с нечетными номерами. Вывести сумму
и произведение.
Б) Переставить в одномерном массиве минимальный элемент и
максимальный.
6. А) Дан одномерный массив из 10 целых чисел. Найти максимальный
элемент и сравнить с ним остальные элементы. Вывести количество
меньших максимального и больших максимального элемента.
Б) Одномерный массив из 10-и целых чисел заполнить с клавиатуры,
определить сумму тех чисел, которые >5.
7. А)Дан массив целых чисел. Найти сумму элементов с четными
номерами и произведение элементов с нечетными номерами. Вывести
сумму и произведение.
Б) Переставить в одномерном массиве минимальный элемент и
максимальный.
8. А) Дан одномерный массив, состоящий из N вещественных элементов.
Ввести массив с клавиатуры. Найти и вывести минимальный по
модулю элемент.
Б) Вывести массив на экран в обратном порядке.
9. А) Даны массивы A и B одинакового размера 10. Вывести исходные
массивы. Поменять местами их содержимое и вывести в начале
элементы преобразованного массива A, а затем — элементы
преобразованного массива B.
Б)
 Вывести все четные элементы массива, делящиеся на 4, введенного
вручную из n элементов.
10.А) Дано количество дней в месяце. Определить возможное время года.
Б) Дан массив случайных чисел длиной n. Отсортировать массив и
среднее арифметическое между максимальным и минимальным элементами,
записать в виде нового массива.

11. А) Даны 2 массива чисел по n элементов в каждом, заданные

случайным образом. Умножить соответствующие элементы обоих массивов и
отсортировать по убыванию.
Б) Даны 6 массивов случайных чисел из k элементов. Найти среднее
арифметическое каждого из массивов и вывести его с индексом того массива,
среднее арифметического которого меньше остальных.
12. А) Задана последовательность чисел длиной n. Получить еще 2
последовательности: первая - квадраты соответствующих элементов, а вторая
составлена из кубов нечетных элементов.
Б) Дан массив случайных чисел из а элементов. Вывести на экран
только те элементы этого массива, индексы которых кратны трем.
13. А) Известно, что 1 число - понедельник, тогда каким днем недели
будет n-ное число месяца.
Б) Задан одномерный массив, длиной k. Найти максимальный элемент
массива.
14. А) Дан массив случайных чисел n элементов. Поменять
симметрично местами (первый с последним, предпоследний со вторым и
т.д.).

Б) Дан массив случайных чисел из n элементов. Вывести числа, в

индексе которых есть число 2.
15. А) Дано количество дней в месяце. Определить возможное время
года.
Б) Дан массив случайных чисел длиной n. Отсортировать массив и
среднее арифметическое между максимальным и минимальным элементами,
записать в виде нового массива.
16.
А) Составить программу, которая находит элемент массива, наиболее
приближенный к среднему арифметическому элементов массива.
Б) Дан одномерный массив. Расположить все положительные элементы
в его начале, а отрицательные — в конце, не нарушая порядка их следования.
В программе можно использовать только один массив.
17.
А) Составить программу, которая вычисляет в одномерном массиве,
состоящем из n вещественных элементов, сумму элементов массива,
расположенных между первым и последним отрицательными элементами.
Б) Дан массив, состоящий из n чисел. Найдите два самых маленьких
числа и замените с самыми максимальными числами.
 18.
А) Составить программу, которая возвращает позицию первого
изменения знака элементов массива.
Б) Написать функцию, определяющую максимальную
последовательность элементов одного знака в одномерном числовом массиве.
19
А) Найти количество элементов массива отличающихся от среднего
менее, чем на 17%.
Б) Используя генератор случайных чисел, заполнить массив
размерностью 10 элементов числами из интервала [-20,+20]. Все чётные
элементы массива уменьшить вдвое и вывести новый массив на печать.
20.
А) Составить программу, которая вычисляет в одномерном массиве,
состоящем из n вещественных элементов, сумму элементов массива,
расположенных между первым и последним нулевыми элементами.
Б) Написать программу, которая зануляет n меньших по модулю
элементов одномерного массива.
21.
А) Дан массив, состоящий из n чисел. Выясните, сколько раз в нем
встречается минимальное число.
Б) В некоторых видах спорта выступление каждого спортсмена
оценивается несколькими судьями, затем из всех оценок удаляются
минимальная и максимальная, а из оставшихся берётся среднее
арифметическое. Если максимальную или минимальную оценку поставили
несколько судей, то удаляется только одна из них. На вход программе сначала
подаётся натуральное число n — количество судей. В следующей строке
следуют n натуральных чисел — оценки, выставленные судьями одному из
спортсменов. Выведите оценку, которая пойдёт в зачёт данному спортсмену.
22.
А) Составить программу, которая вычисляет в одномерном массиве,
состоящем из n вещественных элементов, сумму элементов массива,
расположенных до последнего положительного элемента.
Б) Дан массив, состоящий из n чисел. Выясните, сколько раз в нем
встречается наименьшее число и удалить минимальный элемент массива.
 Тема 12: Модуль numpy
numpy — это модуль (в действительности, набор модулей) языка
Python, добавляющая поддержку больших многомерных массивов и матриц,
вместе с большим набором высокоуровневых (и очень быстрых)
математических функций для операций с этими массивами.
Создание и индексация массивов

Массив — упорядоченный набор значений одного типа,

расположенных в памяти непосредственно друг за другом. При этом доступ к
отдельным элементам массива осуществляется с помощью индексации, то
есть через ссылку на массив с указанием номера (индекса) нужного элемента.
Это возможно потому, что все значения имеют один и тот же тип, занимая
одно и то же количество байт памяти; таким образом, зная ссылку и номер
элемента, можно вычислить, где он расположен в памяти. Количество
используемых индексов массива может быть различным: массивы с одним
индексом называют одномерными, с двумя —двумерными, и т. д.
Одномерный массив («колонка», «столбец») примерно соответствует вектору
в математике (на рис. 5.1(а) a[4] == 56, т.е. четвёртый элемент массива а равен
56); двумерный — матрице (на рис. 5.1(b) можно писать
A[1][6] == 22, можно A[1, 6] == 22). Чаще всего применяются массивы
с одним или двумя индексами; реже — с тремя; ещё большее количество
индексов встречается крайне редко.
Как правило, в программировании массивы делятся на статические и
динамические. Статический массив — массив, размер которого определяется
на момент компиляции программы. В языках с динамической типизацией
таких, как Python, они не применяются. Динамический массив — массив,
размер которого задаётся во время работы программы. То есть при запуске
программы этот массив не занимает нисколько памяти компьютера (может
быть, за исключением памяти, необходимой для хранения ссылки).
Динамические массивы могут
поддерживать и не поддерживать изменение размера в процессе
исполнения программы. Массивы в Python не поддерживают явное
изменение размера: у них, в отличие от списков, нет методов append и extend,
позволяющих добавлять элементы, и методов pop и remove, позволяющих их
удалять. Если нужно изменить размер массива, это можно сделать путём
переприсваивания имени переменной, обозначающей массив, нового
значения, соответствующего новой области памяти, больше или меньше
прежней разными способами.
Базовый оператор создания массива называется array. С его помощью
можно создать новый массив с нуля или превратить в массив уже
существующий список.
from numpy import *
A = array ([0.1 , 0.4 , 3, -11.2 , 9])
print ( A)
print ( type ( A ))

В первой строке из модуля numpy импортируются все функции и

константы.
Вывод программы следующий:
[ 0.1 0.4 3. -11.2 9. ]
<class '[Link]'>
Функция array() трансформирует вложенные последовательности в
много-
мерные массивы. Тип элементов массива зависит от типа элементов
исходной последовательности:
from numpy import *
B = array ([[1 , 2, 3] , [4 , 5, 6]])
print ( B)

Вывод:
[[1 2 3]
[4 5 6]]
Тип элементов массива можно определить в момент создания с
помощью именованного аргумента dtype.
from numpy import *
C = array ([[1 , 2, 3] , [4 , 5, 6]] , dtype = float )
print ( C)

[[1. 2. 3.]
[4. 5. 6.]]
Можно создать массив из диапазона:
from numpy import *
L = range (5)
A = array (L )
print ( A)

[0 1 2 3 4]
 В numpy есть функция arange, позволяющая сразу создать массив-
диапазон, причём можно использовать дробный шаг. Вот программа,
рассчитывающая значения синуса на одном периоде с шагом π/6:
from numpy import *
a1 = arange (0 , 2* pi , pi /6)
s1 = sin ( a1 )
for j in range ( len ( a1 )):
print ( a1 [j], s1 [ j ])

0.0 0.0
0.5235987755982988 0.49999999999999994
1.0471975511965976 0.8660254037844386
1.5707963267948966 1.0
2.0943951023931953 0.8660254037844387
2.617993877991494 0.5000000000000003
3.141592653589793 1.2246467991473532e-16
3.665191429188092 -0.4999999999999997
4.1887902047863905 -0.8660254037844384
4.71238898038469 -1.0
5.235987755982988 -0.866025403784439
5.759586531581287 -0.5000000000000004
Кроме arange есть ещё функция linspace, тоже создающая массив-
диапазон. Её первые два аргумента те же, что и у arange: начало и конец
диапазона, а третий аргумент — количество элементов в диапазоне. К
сожалению, по умолчанию эти функции по разному обрабатывают второй
аргумент: arange берёт его невключительно, linspace — включительно. Это
можно поправить с помощью опционного, четвёртого аргумента linspace,
если установить его в False.
from numpy import *
a=arange(0,2, 0.25)
print (a)

[0. 0.25 0.5 0.75 1. 1.25 1.5 1.75]

Или
from numpy import *
b =linspace (0 , 2, 8, False )
print (b)

[0. 0.25 0.5 0.75 1. 1.25 1.5 1.75]

Массивы построены на базе списков и сохраняют некоторые их черты.
В частности, массивы можно обходить циклом любым из изложенных выше
способов, а функция len возвращает длину массива. Важным свойством
массивов является то, что над ними можно производить операции как над
простыми числами, при этом операция, в нашем случае вычисление синуса,
будет произведена с каждым элементом массива.
 Модуль numpy дублирует и расширяет функционал модуля math, он
содержит все основные тригонометрические, логарифмические и прочие
функции, а также константы, поэтому при работе с numpy надобности в math
обычно не возникает.
Одна из важнейших особенностей массивов — возможность делать
срезы (см. рис. 5.2).

Рис. 5.2. Примеры срезов массивов: чёрным — срезы, в результате

которых из двумерного массива получаются одномерные (из столбца и строки
исходного массива соответственно); тёмносерым — срез, в результате
которого получается двумерный массив меньшего размера.
Срез представляет собою массив из части элементов исходного
массива,
взятых по некоторому простому правилу, например, каждый второй или
первые десять. Вот небольшая программа, иллюстрирующая создание срезов
массивов:
from numpy import *
a1 = arange (0 , 4, 0.5)
print ( a1 )
a2 = a1 [0:4]
print ( a2 )
a3 = a1 [0: len ( a1 ):2]
print ( a3 )

[0. 0.5 1. 1.5 2. 2.5 3. 3.5]

[0. 0.5 1. 1.5]
[0. 1. 2. 3.]
Нужно отметить, что массив-срез делит с исходным массивом память.
Это
значит, что копирование элементов в новый массив не происходит,
вместо этого просто делается сложная ссылка. Поэтому изменение элементов
исходного массива приводит к изменению элементов массива-среза и
наоборот. Чтобы скопировать элементы, нужно воспользоваться функцией
copy.
from numpy import *
a1 = arange (0 , 0.6 , 0.1)
a2 = a1[:len(a1):2]
print ( a1 , a2 )
a1 [0] = 10
a1 [ -1] = a1 [ -1] + 3
print ( a1 , a2 )
a2 [1] = 0
print ( a1 , a2 )

[0. 0.1 0.2 0.3 0.4 0.5] [0. 0.2 0.4]

[10. 0.1 0.2 0.3 0.4 3.5] [10. 0.2 0.4]
[10. 0.1 0. 0.3 0.4 3.5] [10. 0. 0.4]
с использованием функции copy:
from numpy import *
a1 = arange (0 , 0.6 , 0.1)
a2 = copy ( a1 [: len ( a1 ):2])
print ( a1 , a2 )
a1 [0] = 10
a1 [ -1] = a1 [ -1] + 3
print ( a1 , a2 )
a2 [1] = 0
print ( a1 , a2 )

[0. 0.1 0.2 0.3 0.4 0.5] [0. 0.2 0.4]

[10. 0.1 0.2 0.3 0.4 3.5] [0. 0.2 0.4]
[10. 0.1 0.2 0.3 0.4 3.5] [0. 0. 0.4]
Функция array() не единственная функция для создания массивов.
Обычно
элементы массива вначале неизвестны, а массив, в котором они будут
храниться, уже нужен. Поэтому имеется несколько функций для того, чтобы
создавать массивы с каким-то исходным содержимым.
ones создаёт массив из единиц, zeros — массив из нулей, empty —
массив, значения элементов которого могут быть какими угодно (берётся то,
что лежало в ячейках памяти до того, как в них был размещён массив). Все
эти функции принимают единственный параметр — длину вновь
создаваемого массива.
пример:
from numpy import *
a1 = ones (5)
a2 = zeros (3)
a3 = empty (4)
 print ( a1 )
print ( a2 )
print ( a3 )

[1. 1. 1. 1. 1.]
[0. 0. 0.]
[0. 1. 2. 3.]
Если массив слишком большой, чтобы его печатать, numpy
автоматически
скрывает центральную часть массива и выводит только его уголки:
from numpy import *
A = arange (0 , 3000 , 1)
print ( A)

[ 0 1 2 ... 2997 2998 2999]

Арифметические операции и функции с массивами

Python — объектно-ориентированный язык программирования. Каждая
переменная Python — объект, хотя часто это совсем незаметно. Поэтому
многие переменные Python имеют встроенные методы — присущие им
функции — и свойства. Так, массивы имеют ряд очень простых, но полезных
методов, сильно упрощающих жизнь при написании сложных программ.
Собственно, именно поэтому в сложных программах удобнее использовать
именно массивы, а не списки.
Самые часто используемые занесены в таблицу 5.1. Пусть у нас есть
массив вида
import numpy
a=[Link]([0.1, 0.25, -1.75, 0.4, -0.9]):
 from numpy import *
a = array ([0.1 , 0.25 , -1.75 , 0.4 , -0.9])
print ( a. sum ())
print ( a. mean ())
print ( a. min ())
print ( a. max ())
print ( a. var ())
print ( a. std ())

-1.9
-0.38
-1.75
0.4
0.6766
0.8225569889071517
Поскольку Python язык очень глубоко объектный, сами по себе методы,
как и их параметры и результаты, тоже являются объектами. Тип результата
встроенных функций определяется их природою: min, max и sum всегда того
же типа, что и элементы массива, а вот var, mean и std всегда
действительнозначные, поскольку для их вычисления выполняются деление и
— для std — извлечение квадратного корня.
массивы numpy можно складывать, как простые числа, прибавлять к
ним число, умножать и делить друг на друга и на число. При этом

все операции происходят поэлементно. Пример программы сложения

двух
массивов и умножения массива на число:
 from numpy import *
a = array ([0.1 , 0.25 , -1.75 , 0.4 , -0.9])
b = array ([0.9 , 1.75 , -0.15 , 0.4 , 0.4])
c=a+b
print (c)
d = a + 1.5
print ( d)

[ 1. 2. -1.9 0.8 -0.5]

[ 1.6 1.75 -0.25 1.9 0.6 ]
Такие операции называются иногда «векторными» в том смысле, что
одинаковые действия производятся сразу с большим набором данных.
Складывать можно только массивы одинаковой длины. Аналогично можно
перемножать массивы. Число можно прибавлять к любому массиву или
умножать массив на число, в результате получается массив того же размера,
что и исходный, а каждый его элемент есть результат сложения (или
умножения) соответствующего элемента исходного массива и числа.
В векторных операциях можно использовать как целые массивы, так и
их
срезы:
from numpy import *
a = array ([0.1 , 0.25 , -1.75 , 0.4 , -0.9])
b = array ([0.9 , 1.75 , -0.15 , 0.4 , 0.4])
c = a [:3] + b [1:4]
print (c)
d = a [2:4]* a [0:2]
print (d)

[ 1.85 0.1 -1.35]

[-0.175 0.1 ]
Обратите внимание ещё раз: при перемножении массивов действия
производятся поэлементно, в результате чего получается новый массив той
же длины, а вовсе не их векторное произведение, как это принято в
некоторых математических пакетах. Вот пример:
import numpy
a=numpy . array ([ -1.75 , 0.4]) * numpy . array ([0.1 , 0.25])
print(a)

[-0.175 0.1 ]
Кроме арифметических операций над массивами можно также векторно
выполнять все заложенные в numpy функции, например, взять синус или
логарифм от массива (если написать просто log(X), то получится
натуральный логарифм, иначе нужно написать основание логарифма вторым
аргументом log(X, 10)).
пример:
 from numpy import *
t = arange (0 , pi , pi /6)
x = sin (t)
y = log (t)
print ( t)
print ( x)
print ( y)

[0. 0.52359878 1.04719755 1.57079633 2.0943951 2.61799388]

[0. 0.5 0.8660254 1. 0.8660254 0.5 ]
[ -inf -0.64702958 0.0461176 0.45158271 0.73926478 0.96240833]

Массивы numpy можно обходить циклом, как списки. Чтобы сделать

наше
табулирование более удобным и привычным для чтения,
модифицируем предыдущую программу, чтобы она выдавала результат своей
работы в три столбца. Для этого заменим последнюю строку, где стоят
операторы print, на две новые:
for i in range ( len (t )):
print (t [i],’\t’, x[i], y[ i ])

0.0 0.0 -inf

0.5235987755982988 0.49999999999999994 -0.6470295833786549
1.0471975511965976 0.8660254037844386 0.046117597181290375
1.5707963267948966 1.0 0.4515827052894548
2.0943951023931953 0.8660254037844387 0.7392647777412357
2.617993877991494 0.5000000000000003 0.9624083290554454

Двумерные массивы, форма массивов

Никакие сложные вычисления не могут обойтись без двумерных
массивов,
часто называемых матрицами. Модуль numpy позволяет оперировать с
массивами произвольной размерности: одномерными, двумерными,
трёхмерными и т. д.
Чтобы работать с массивами произвольной размерности, удобно
пользоваться понятием формы (shape). Форма — совокупность длин массива
по каждому измерению. Обычно форма задаётся в виде кортежа из
нескольких чисел: двух для двумерного, трёх для трёхмерного и т. д. Форма
— свойство массива и обозначается shape. Форму массива можно задать при
его создании. Если массив создаётся при помощи какой-нибудь встроенной
функции numpy, его форма определяется этой функцией. Для одномерных
массивов форма — это просто его длина.
from numpy import *
x = zeros ((2 , 3))
y = eye (3)
 print ( x)
print ( y)
print ( x. shape )
print ( len (x ))
print ( y. shape )

[[0. 0. 0.]
[0. 0. 0.]]

[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

(2, 3)
2
(3, 3)
В приведённом примере мы создали матрицу размера 2 × 3 из нулей с
помощью функции zeros (в качестве аргумента передаём кортеж из двух
числе (2, 3)); аналогично можно создать матрицу произвольного размера.
Функция eye принимает единственный скалярный аргумент, поскольку она
создаёт единичную квадратную матрицу заданного размера. Видно, что длина
массива (len) — это его первая размерность (в ранних версиях numpy длина
соответствовала общему числу элементов, т. е. произведению размерностей).
Также к двумерным массивам применимы операции sum, mean, max и т.
д. По умолчанию, эти операции применяются к массиву, как если бы он был
линейным списком всех чисел, независимо от его формы. Однако, указав
параметр axis, можно применить операцию для указанной оси массива:
from numpy import *
a = array ([[1 , 2, 3] , [4 , 5, 6]])
print ( a. sum ())
print ( a. sum ( axis =0))
print ( a. sum ( axis =1))
print ( a. min ())
print ( a. min ( axis =0))
print ( a. min ( axis =1))

21
[5 7 9]
[ 6 15]
1
[1 2 3]
[1 4]
Видно, что axis=0 работает с каждым столбцом отдельно, а axis=1 — с
каждою строкою отдельно.
Итерирование многомерных массивов начинается с нулевой оси:
 from numpy import *
a = array ([[1 , 2, 3] , [4 , 5, 6]])
for element in a:
print ( element )

[1 2 3]
[4 5 6]
Однако если нужно перебрать поэлементно весь массив, как если бы он
был одномерным, для этого можно использовать атрибут flat:
for element in a. flat :
print ( element )

1
2
3
4
5
6
Пример. Вычисление определителя матрицы в python
from numpy import*
a = array([ [2, 1], [4, 3] ]) 2 1
4 3
print([Link](a))

2.0
Пример. Умножение матрицы на матрицу в python
from numpy import*
a = array([ [2, 1, 3], [2, 2, 4] ])
b = array([ [1, 1], [3, 2], [2, 4] ])
total = [Link](b)
print(total)

[[11 16]
[16 22]]
Пример. Возведение матрицы в степень в python
from numpy import*
a = array([[1, 3], [2, 1]])
result = linalg.matrix_power(a, 2)
print(result)

[[7 6]
[4 7]]
Решение системы линейных уравнений в python
1x + 2y = 5
3x + 2y = 6
from numpy import*
a = array([[1, 2], [3, 2]])
b = array([5, 6])
result = [Link](a, b)
print(result)

[0.5 2.25]
Пример. Возведение вектора в экспоненту.
from numpy import*
a = array([2, 1, 5])
print(exp(a)) ex

[ 7.3890561 2.71828183 148.4131591 ]

Пример. Умножение матрицы на вектор в python
from numpy import*
a = array([ [2, 1], [2, 2], [4, 3] ])
b = array([ [1], [3] ])
total = [Link](b)
print(total)

[[ 5]
[ 8]
[13]]
обратная матрица.
from numpy import*
a = array([ [2, 1], [4, 3] ])
print([Link](a))

[[ 1.5 -0.5]
[-2. 1. ]]
собственные значения и собственные векторы.
from numpy import*
a = array([ [2, 1], [4, 3] ])
print([Link](a))

(array([0.43844719, 4.56155281]), array([[-0.5392856 , -0.36365914],

[ 0.84212294, -0.93153209]]))

Тема 2.1 Создание матрицы

В Python существует несколько способов создания матрицы.
  С помощью списков. Можно создать матрицу, используя вложенные
списки. Каждый вложенный список будет соответствовать одной
строке. Так можно создать квадратную матрицу Python:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

 С помощью NumPy. NumPy — это библиотека для математических
вычислений и обработки данных. В ней есть класс Array, который
можно использовать для создания матрицы:
 import numpy as np
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)
Матричные операции
 Сложение. Две матрицы можно сложить, если их размеры совпадают.
Каждый элемент итоговой матрицы будет равен сумме
соответствующих элементов исходных матриц.
Пример сложения с помощью вложенных списков и циклов:

matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

matrix2 = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

for i in range(len(matrix1)):
for j in range(len(matrix1[0])):
result[i][j] = matrix1[i][j] + matrix2[i][j]

print(result)

Вот аналогичное сложение с помощью метода add() из библиотеки

NumPy:

import numpy as np
matrix1 = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix2 = [Link]([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
result = [Link](matrix1, matrix2)
print(result)

 Вычитание. Одну матрицу можно вычесть из другой, если их размеры

совпадают. Каждый элемент итоговой матрицы будет равен разности
соответствующих элементов исходных матриц.
Вычитание с помощью цикла:
matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix2 = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

for i in range(len(matrix1)):
 for j in range(len(matrix1[0])):
result[i][j] = matrix1[i][j] - matrix2[i][j]

print(result)

Вычитание с помощью метода subtract() из библиотеки NumPy:

import numpy as np
matrix1 = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
matrix2 = [Link]([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
result = [Link](matrix1, matrix2)
print(result)

 Умножение на число. Каждый элемент итоговой матрицы будет равен

произведению соответствующего элемента исходной матрицы на число.
В Python умножение матрицы на число можно реализовать с помощью
цикла или воспользоваться методом dot() из библиотеки NumPy.
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
scalar = 2
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

for i in range(len(matrix)):
for j in range(len(matrix[0])):
result[i][j] = matrix[i][j] * scalar

print(result)
с помощью метода dot()

import numpy as np
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
scalar = 2
result = [Link](matrix, scalar)
print(result)

Также вместо метода dot() можно использовать знак операции

умножения *:
import numpy as np

matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

scalar = 2

result = matrix * scalar

print(result)
В большинстве случаев метод dot() работает быстрее вручную
реализованных циклов.
  Произведение матриц. Матрицы можно перемножить, если
число столбцов первой матрицы равно числу строк второй матрицы. В
результате получится новая матрица с размером, соответствующим
числу строк первой матрицы и числу столбцов второй матрицы. Более
подробно эту операцию мы разберем чуть дальше.
Умножение, реализованное на циклах, может иметь такой вид:
matrix1 = [[1, 2], [3, 4]]
matrix2 = [[5, 6], [7, 8]]
result = [[0, 0], [0, 0]]

for i in range(len(matrix1)):
for j in range(len(matrix2[0])):
for k in range(len(matrix2)): result[i][j] += matrix1[i][k] *
matrix2[k][j]

print(result)

В NumPy для матричного умножения используется метода dot():

import numpy as np

matrix1 = [Link]([[1, 2], [3, 4]])

matrix2 = [Link]([[5, 6], [7, 8]])

result = [Link](matrix1, matrix2)

print(result)

Аналогично методу dot() работает операция @:

import numpy as np

matrix1 = [Link]([[1, 2], [3, 4]])

matrix2 = [Link]([[5, 6], [7, 8]])

result = matrix1 @ matrix2

print(result)
Использование метода dot() или оператора @ даёт более быстрый, по
сравнению с использованием вручную реализованных циклов, результат.

 Транспонирование матрицы. Транспонирование — это операция, в

которой строки и столбцы меняются местами. Т.е. первый столбец
становится первой строкой, второй столбец — второй строкой и так
далее.
 В Python можно выполнить транспонирование с помощью
свойства T или метода transpose() из библиотеки NumPy.
Пример транспонирования с использованием свойства T:
import numpy as np
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

result = matrix.T

print(result)

Пример транспонирования с использованием метода transpose():

import numpy as np
matrix = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

result = [Link](matrix)

print(result)

 Нахождение обратной матрицы. Матрица B будет являться обратной

матрицей для матрицы A, если результатом операции A*B является
единичная матрица.

В Python можно найти обратную матрицу с помощью метода inv() из

библиотеки NumPy.
import numpy as np

matrix = [Link]([[1, 2], [3, 4]])

result = [Link](matrix)

print(result)
 Задания. Массивы, модуль numpy.
Задание 1.1. Операции с векторами и матрицами
1.Создать:
– произвольную вектор-строку (v);
– произвольный вектор-столбец (w);
– произвольную матрицу (m).
– матрицу с нулевыми элементами (m0), рарности 2×3;
– матрицу с единичными элементами(m1), размерности 4×4;
– матрицу с элементами, имеющими случайные значения(mr), размерности
3×5
– матрицу с единичными диагональными элементами(me), размерности 3×3.
2. Изучение функций обработки данных:
– определение максимального элемента матрицы M;
– определение минимального элемента матрицы M;
– суммирование элементов матрицы M;
– перемножение элементов матрицы M.
3. Дана матрица А:
- Найти обратную матрицу для матрицы А;
- вывести транспонированную матрицу;
- вычислить определитель матрицы А;
- найти λ*А, сумму, произведение матрицы А с произвольной матрицей
В.
1. 7.
2.

8.

3.

9.

4. 10.

5. 11.

6. 12.

13. 14.

B=

15. 16.

B= B=

1.2 Решить систему линейных уравнений

11. 12.

13. 14.

15. 16.

17. 18.
 Тема: Работа с pandas.
Анализ данных на Python

Pandas - это высокоуровневая Python библиотека для анализа данных.

В экосистеме Python, pandas является наиболее продвинутой и
быстроразвивающейся библиотекой для обработки и анализа данных.
Pandas — это библиотека Python с открытым исходным кодом для
специализированного анализа данных. Библиотека была спроектирована и
разработана преимущественно Уэсом Маккини в 2008 году. В 2012 к нему
присоединился коллега Чан Шэ. Вместе они создали одну из самых
используемых библиотек в сообществе Python.
Pandas появилась из необходимости в простом инструменте для
обработки, извлечения и управления данными.
Этот пакет Python спроектирован на основе библиотеки NumPy. Такой
выбор обуславливает успех и быстрое распространение pandas. Он также
пользуется всеми преимуществами NumPy и делает pandas совместимой с
большинством другим модулей.
Еще одно важное решение — разработка специальных структур для
анализа данных. Вместо того, чтобы использовать встроенные в Python или
предоставляемые другими библиотеками структуры, были разработаны две
новых.
Они спроектированы для работы с реляционными и
классифицированными данными, что позволяет управлять данными
способом, похожим на тот, что используется в реляционных базах SQL и
таблицах Excel.
 В Pandas можно изучить набор данных, почистить его, внести
изменения, проанализировать и сделать выводы, построить графики и многое
другое.
В отличие от Excel, где тоже широкие возможности для работы с
данными, Pandas справится даже с очень большими файлами, в которых
сотни тысяч и миллионы строк.
Установка Pandas
Для начала Pandas нужно установить.
pip install pandas
DataFrame и Series
Самые главные структуры данных библиотеки: DataFrame и Series.
Series
Структура/объект Series представляет из себя объект, похожий на
одномерный массив (список, например), но отличительной его чертой
является наличие ассоциированных меток, т.н. индексов, вдоль каждого
элемента из списка. Такая особенность превращает его в ассоциативный
массив или словарь в Python.
import pandas as pd
my_series = [Link]([5, 6, 7, 8, 9, 10])
print(my_series)
Результат:
0 5
1 6
2 7
3 8
4 9
5 10
dtype: int64

В строковом представлении объекта Series, индекс находится слева, а

сам элемент справа. Если индекс явно не задан, то pandas автоматически
создаёт RangeIndex от 0 до N-1, где N общее количество элементов. Также
стоит обратить, что у Series есть тип хранимых элементов, в нашем случае
это int64, т.к. мы передали целочисленные значения.
У объекта Series есть атрибуты через которые можно получить список
элементов и индексы, это values и index соответственно.
print(my_series.index)
print(my_series.values)
Результат:
RangeIndex(start=0, stop=6, step=1)
array([ 5, 6, 7, 8, 9, 10], dtype=int64)

Доступ к элементам объекта Series возможны по их индексу ( аналогия

со словарем и доступом по ключу).
print(my_series[4])
 9

Индексы можно задавать явно:

my_series2 = [Link]([5, 6, 7, 8, 9, 10], index=['a', 'b', 'c', 'd', 'e', 'f'])
print(my_series2)
print( my_series2['f'])
Рез:
a 5
b 6
c 7
d 8
e 9
f 10
dtype: int64
10

Делать выборку по нескольким индексам и осуществлять групповое

присваивание:
print(my_series2[['a', 'b', 'f']])
Рез:
a 5
b 6
f 10
dtype: int64

my_series2[['a', 'b', 'f']] = 0

print(my_series2)
Рез:
a 0
b 0
c 7
d 8
e 9
f 0
dtype: int64

Фильтровать Series, а также применять математические операции и

многое другое:
print(my_series2[my_series2 > 0])
Рез:
c 7
d 8
e 9
dtype: int64
 print(my_series2[my_series2 > 0] * 2)
Рез:
c 14
d 16
e 18
dtype: int64

Если Series напоминает нам словарь, где ключом является индекс, а

значением сам элемент, то можно сделать так:
my_series3 = [Link]({'a': 5, 'b': 6, 'c': 7, 'd': 8})
print(my_series3)
Рез:
a 5
b 6
c 7
d 8
dtype: int64

print('d' in my_series3)
Рез:
True

У объекта Series и его индекса есть атрибут name, задающий имя

объекту и индексу соответственно.
my_series3.name = 'numbers'
my_series3.[Link] = 'letters'
print(my_series3)
Рез:
letters
a 5
b 6
c 7
d 8
Name: numbers, dtype: int64
Индекс можно поменять, присвоив список атрибуту index объекта
Series
my_series3.index = ['A', 'B', 'C', 'D']
print(my_series3)
Рез:
A 5
B 6
C 7
D 8
Name: numbers, dtype: int64
 список с индексами по длине должен совпадать с количеством
элементов в Series.
DataFrame
Объект DataFrame - представляет в виде обычной таблицы. DataFrame
является табличной структурой данных. В любой таблице всегда
присутствуют строки и столбцы. Столбцами в объекте DataFrame выступают
объекты Series, строки которых являются их непосредственными элементами.
df = [Link]({
'Страна': ['Кыргызстан','Казакстан', 'Россия', 'Украина'],
'Население': [6.5,17.04, 143.5, 45.5],
'Площадь': [207600,2724902, 17125191, 603628]
})
print(df)
Рез:

Или
import pandas as pd
dict_city={"Город":["Бишкек","Москва", "Астана"],"Население":
[10500620,12652250,4058621]}
df=[Link](dict_city)
print(df)

Результат:

Чтобы убедиться, что столбец в DataFrame это Series, извлекаем любой:

print(df['Страна'])
Рез:
 Объект DataFrame имеет 2 индекса: по строкам и по столбцам. Если
индекс по строкам явно не задан (например, колонка по которой нужно их
строить), то pandas задаёт целочисленный индекс RangeIndex от 0 до N-1, где
N это количество строк в таблице.
print([Link])
Рез:
Index(['Страна', 'Население', 'Площадь'], dtype='object')
print([Link])
Рез:
RangeIndex(start=0, stop=4, step=1)

В таблице у нас 4 элемента от 0 до 3.

Доступ по индексу в DataFrame
Индекс по строкам можно задать разными способами, например, при
формировании самого объекта DataFrame:
df = [Link]({
'Страна': ['Кыргызстан','Казакстан', 'Россия', 'Украина'],
'Население': [6.5,17.04, 143.5, 45.5],
'Площадь': [207600,2724902, 17125191, 603628]
},index=['KG', 'KZ','RU', 'UA'])
print(df)
)
Рез:

[Link] = ['KG', 'KZ', 'RU', 'UA']

[Link] = 'Код страны'
print(df)
Рез:

Как видно, индексу было задано имя – Код страны. объекты Series из
DataFrame будут иметь те же индексы, что и объект DataFrame:
print(df['Страна'])
Рез:
 Доступ к строкам по индексу возможен несколькими способами:
 .loc - используется для доступа по строковой метке
 .iloc - используется для доступа по числовому значению (начиная от 0)
print([Link]['KZ'])
Рез:

print([Link][0])
Рез:

Можно делать выборку по индексу и интересующим колонкам:

print([Link][['KZ', 'RU'], 'Население'])
Рез:
Код страны
KZ 17.04
RU 143.50
Name: Население, dtype: float64

Как можно заметить, .loc в квадратных скобках принимает 2 аргумента:

интересующий индекс, в том числе поддерживается слайсинг и колонки.
print([Link]['KG':'RU', :])
Рез:

Фильтровать DataFrame с помощью т.н. булевых массивов:

 print(df[df.Население > 10][['Страна','Площадь']])
Рез:

К столбцам можно обращаться, используя атрибут или нотацию

словарей Python, т.е. df.Население и df['Население'] это одно и то же.
Сбросить индексы можно следующим образом:
print(df.reset_index())
Рез:

pandas при операциях над DataFrame, возвращает новый объект

DataFrame.
Добавим новый столбец, в котором население (в миллионах) поделим
на площадь страны, получив тем самым плотность:
df['Плотность'] = df['Население'] / df['Площадь'] * 1000000
print(df)
Рез:

Удалить столбца:
print([Link](['Плотность'], axis='columns'))
Рез:

Или можно написать

 del df['Площадь']
print(df)
Рез:

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

print([Link](columns={'Страна':'Республика'}))
Рез:

Чтение и запись файлов Excel (XLSX) в Python

Pandas можно использовать для чтения и записи файлов Excel с
помощью Python. Это работает по аналогии с другими форматами.
Ядром pandas являются две структуры данных, в которых происходят
все операции:
 Series
 Dataframes
Series — это структура, используемая для работы с
последовательностью одномерных данных, а Dataframe — более сложная и
подходит для нескольких измерений.
Пусть они и не являются универсальными для решения всех проблем,
предоставляют отличный инструмент для большинства приложений. При
этом их легко использовать, а множество более сложных структур можно
упросить до одной из этих двух.
Pandas можно использовать для чтения и записи файлов Excel с
помощью Python. Это работает по аналогии с другими форматами.
Рассмотрим, как это делается с помощью DataFrame.
Помимо чтения и записи рассмотрим, как записывать несколько
DataFrame в Excel-файл, как считывать определенные строки и колонки из
таблицы и как задавать имена для одной или нескольких таблиц в файле.
Установка Pandas
Для начала Pandas нужно установить.
pip install pandas
далее нужно установить недостающие модули:
pip install openpyxl xlsxwriter xlrd
 Запись в файл Excel с python
Будем хранить информацию, которую нужно записать в файл Excel,
в DataFrame. А с помощью встроенной функции to_excel() ее можно будет
записать в Excel.
Сначала импортируем модуль pandas. Потом используем словарь для
заполнения DataFrame:
import pandas as pd
df = [Link]({'Имя': ['Асел', 'Асан', 'Жаныл',
'Азамат', 'Турат'],
'Место работы': ['Мегаком', 'Банк Кыргызстан',
'Демир банк', 'KFS',
'КГУСТА'],
'Оклад': [30000, 20000, 22000,
15000, 12000]})

df.to_excel('./[Link]')
Ключи в словаре — это названия колонок. А значения станут строками
с информацией.
Теперь можно использовать функцию to_excel() для записи
содержимого в файл. Единственный аргумент — это путь к файлу:

Стоит обратить внимание на то, что в этом примере не использовались

параметры. Таким образом название листа в файле останется по умолчанию
— «Sheet1». В файле может быть и дополнительная колонка с числами. Эти
числа представляют собой индексы, которые взяты напрямую из DataFrame.
Поменять название листа можно, добавив параметр sheet_name в
вызов to_excel():
df.to_excel('./[Link]', sheet_name='Budgets', index=False)
Также можно добавили параметр index со значением False, чтобы
избавиться от колонки с индексами.
Запись нескольких DataFrame в файл Excel
 Также есть возможность записать несколько DataFrame в файл Excel.
Для этого можно указать отдельный лист для каждого объекта:

salaries1 = [Link]({'Имя': ['Асел', 'Айжан', 'Самат'],

'Оклад': [56000, 22000, 12500]})

salaries2 = [Link]({'Имя': ['Болот', 'Жанна', 'Максат'],

'Оклад': [37000, 27000, 24000]})

salaries3 = [Link]({'Имя': ['Асанов', 'Океев', 'Бекова'],

'Оклад': [16000, 26000, 25000]})

salary_sheets = {'Group1': salaries1, 'Group2': salaries2, 'Group3': salaries3}

writer = [Link]('./[Link]', engine='xlsxwriter')

for sheet_name in salary_sheets.keys():

salary_sheets[sheet_name].to_excel(writer, sheet_name=sheet_name,
index=False)

[Link]()

Здесь создаются 3 разных DataFrame с разными названиями, которые

включают имена сотрудников, а также размер их зарплаты. Каждый объект
заполняется соответствующим словарем.
Объединим все три в переменной salary_sheets, где каждый ключ будет
названием листа, а значение — объектом DataFrame.
 Дальше используем движок xlsxwriter для создания объекта writer. Он и
передается функции to_excel().
Перед записью пройдемся по ключам salary_sheets и для каждого ключа
запишем содержимое в лист с соответствующим именем.
Можно увидеть, что в этом файле Excel есть три листа: Group1, Group2
и Group3. Каждый из этих листов содержит имена сотрудников и их зарплаты
в соответствии с данными в трех DataFrame из кода.
Параметр движка в функции to_excel() используется для определения
модуля, который задействуется библиотекой Pandas для создания файла Excel.
В этом случае использовался xslswriter, который нужен для работы с
классом ExcelWriter. Разные движка можно определять в соответствии с их
функциями.
В зависимости от установленных в системе модулей Python другими
параметрами для движка могут быть openpyxl (для xlsx или xlsm) и xlwt (для
xls). Подробности о модуле xlswriter можно найти в официальной
документации.
Наконец, в коде была строка [Link](), которая нужна для
сохранения файла на диске.
 Чтение файлов Excel с python
По аналогии с записью объектов DataFrame в файл Excel, эти файлы
можно и читать, сохраняя данные в объект DataFrame. Для этого достаточно
воспользоваться функцией read_excel():
teamsread = pd.read_excel('./[Link]')
print([Link]())

Содержимое финального объекта можно посмотреть с помощью

функции head().
Pandas присваивает метку строки или числовой индекс
объекту DataFrame по умолчанию при использовании функции read_excel().
Это поведение можно переписать, передав одну из колонок из файла в
качестве параметра index_col:
teamsread = pd.read_excel('./[Link]',index_col='Имя')
print([Link]())
 В этом примере индекс по умолчанию был заменен на колонку «Name»
из файла. Однако этот способ стоит использовать только при наличии
колонки со значениями, которые могут стать заменой для индексов.
Чтение определенных колонок из файла Excel
Иногда удобно прочитать содержимое файла целиком, но бывают
случаи, когда требуется получить доступ к определенному элементу.
Например, нужно считать значение элемента и присвоить его полю объекта.
Это делается с помощью функции read_excel() и параметра usecols.
Например, можно ограничить функцию, чтобы она читала только
определенные колонки. Добавим параметр, чтобы он читал колонки, которые
соответствуют значениям «Имя», «Оклад».
Для этого укажем числовой индекс каждой колонки:
cols = [1, 3]
teamsread = pd.read_excel('./[Link]',usecols=cols)
print([Link]())

Таким образом возвращаются лишь колонки из списка cols.