Основы программирования на языке Python

материала

изображений;
поддержка форматов BMP, EPS, GIF, JPEG, PDF, PNG, PNM, TIFF и некоторых других на чтение и запись;
поддержка множества форматов (ICO, MPEG, PCX, PSD, WMF и др.) только для чтения;
преобразование изображений из одного формата в другой;
правка изображений (использование различных фильтров, масштабирование, рисование, матричные операции и т. д.);
использование библиотеки из Tkinter и PyQt.

В настоящее время актуальный модуль – pillow, модификация библиотеки PIL

Официальная страница поддержки http://www.pythonware.com/products/pil/

i in range(x // 2): for j in range(y): pixels[i, j], pixels[x - i - 1, j] \ = pixels[x - i - 1, j], pixels[i, j]

pixels[i, j], pixels[i, y - j - 1] \ = pixels[i, y - j - 1], pixels[i, j]

pixels[i, j], pixels[j, i] \ = pixels[j, i], pixels[i, j]

- i): pixels[j, i], pixels[x - i - 1, x - j - 1] \ = pixels[x - i - 1, x - j - 1], pixels[j, i]

левую нижнюю четверти изображения.
Параметр input_file_name задаёт имя исходного файла, а output_file_name — имя файла, куда следует сохранить результат.

Некоторые примеры

im.load() x, y = im.size for i in range(x // 2, x): for j in range(y // 2): pixels[i, j], pixels[x - i - 1, y - j - 1] \ = pixels[x - i - 1, y - j - 1], pixels[i, j] im.save(output_file_name)

изображения

im.load() x, y = im.size for i in range(x // 2, x): for j in range(y // 2, y): pixels[i, j], pixels[x - i - 1, y - j - 1] \ = pixels[x - i - 1, y - j - 1], pixels[i, j] im.save(output_file_name)

Draw из библиотеки ImageDraw. У этого объекта есть много инструментов для создания графических примитивов: прямых, кривых, точек, прямоугольников, дуг и т.д.

new_image = Image.new('RGB', (x_size, y_size), (r, g, b))

Функция создания «холста»

Палитра

Размеры по осям x и y

Код цвета в палитре

Подробно про библиотеку ImageDraw: https://pillow.readthedocs.io/en/stable/reference/ImageDraw.html#functions

import Image, ImageDraw new_image = Image.new("RGB", (100, 200), (0, 0, 0)) draw = ImageDraw.Draw(new_image) draw.line((0, 0, 100, 200), fill=(255, 0, 0), width=1) # сохраним изображением в файл формата PNG new_image.save('line.png', 'PNG')

На черном прямоугольнике размера 100*200 создать красную линию, проходящую из левого верхнего в правый нижний угол, толщиной 1

– красный, начинающийся в левом верхнем углу, зеленый – посередине и синий, заканчивающийся в правом нижнем углу

from PIL import Image, ImageDraw new_image = Image.new("RGB", (200, 200), (0, 0, 0)) draw = ImageDraw.Draw(new_image) draw.rectangle((0, 0, 50, 50), fill=(255, 0, 0)) draw.rectangle((75, 75, 125, 125), fill=(0, 255, 0)) draw.rectangle((150, 150, 200, 200), fill=(0, 0, 255)) new_image.save('rectangle.png', 'PNG')

левого края. Холст – квадрат 500*500, линия толщиной 10

from PIL import Image, ImageDraw new_image = Image.new("RGB", (500, 500), (0, 0, 0)) draw = ImageDraw.Draw(new_image) color = 0, 0, 255 draw.line((50, 0, 50, 500), fill=color, width=10) new_image.save('line.png', 'PNG')

PIL import Image, ImageDraw new_image = Image.new("RGB", (100, 100), (0, 0, 0)) draw = ImageDraw.Draw(new_image) color = 0, 0, 255 draw.arc((10, 10, 90, 90), -45, 90, fill=color, width=10) new_image.save('arc.png', 'PNG')

0)) draw = ImageDraw.Draw(new_image) color = 255, 0, 255 draw.polygon((10, 10, 500, 150, 20, 200), fill='white', outline=color) new_image.save('poligon.png', 'PNG')

Рисуем многоугольник

Координаты вершин

Цвет фона

Цвет границы

– красный, начинающийся в правом верхнем углу, зеленый – посередине и синий, заканчивающийся в левом нижнем углу

from PIL import Image, ImageDraw new_image = Image.new("RGB", (200, 200), (0, 0, 0)) draw = ImageDraw.Draw(new_image) draw.ellipse((150, 0, 200, 50), fill=(255, 0, 0)) draw.ellipse((75, 75, 125, 125), fill=(0, 255, 0)) draw.ellipse((0, 150, 50, 200), fill=(0, 0, 255)) new_image.save('circule.png', 'PNG')

0)) draw = ImageDraw.Draw(new_image) draw.rectangle((0, 100, 300, 200), fill=(255, 255, 255)) new_image.save('rectangle.png', 'PNG')

По середине черного квадрата размера 300*300 сделать горизонтальную полосу толщиной 100

= Image.new("RGB", (300, 300), (0, 0, 0)) draw = ImageDraw.Draw(new_image) draw.rectangle((0, 100, 300, 200), fill=(255, 255, 255)) draw.ellipse((100, 100, 200, 200), fill=(255, 0, 0)) new_image.save('rectangle1.png', 'PNG')

size): new_image = Image.new("RGB", (num * size, num * size), (0, 0, 0)) draw = ImageDraw.Draw(new_image)

Объявим функцию, аргументы которой - количество клеток по горизонтали (и по вертикали) и размер клетки.
Внутри функции создадим новое изображение соответствующего размера, на черном фоне

2, num, 2): draw.rectangle((x * size, y * size, (x + 1) * size - 1, (y + 1) * size - 1), fill=(255, 255, 255))

Заполняем поле белыми квадратами

Сохраняем получившееся изображение в файле

new_image.save('res.png', "PNG")

надо нарисовать с помощью графических примитивов (линий, дуг и прочее), для заливки так же необходимо использовать функции библиотеки PIL.
Главное правило – не использовать встроенные шрифты.
Сохраните полученный рисунок в файле name.png.

В качестве примера – имя «Дима»

0))

Импортируем из библиотеки необходимые элементы.
Создаем основу – черное поле размера 700 на 300

draw.rectangle((25, 0, 50, 300), 'yellow')

Желтый прямоугольник

draw.arc(((0, 0), (100, 300)), -90, 90, 'green', 25)

Зеленая дуга

draw.rectangle((125, i * 50, 150, i * 50 + 50), color[i]) draw.rectangle((200, i * 50, 225, i * 50 + 50), color[i])

Две вертикальных палочки в букве «И». Сделаем их разного цвета

Перекладина буквы «И». Оранжевая

draw.line(((150, 300), (200, 0)), 'orange', 20)

объект эллипс -

draw.ellipse

for i in range(0, 300, 50): draw.ellipse(((250, i), (300, i + 50)), 'green') draw.ellipse(((450, i), (500, i + 50)), 'yellow')

Две вертикальных палочки в букве «M».

draw.ellipse(((300, 50), (350, 100)), 'red') draw.ellipse(((400, 50), (450, 100)), 'white') draw.ellipse(((350, 100), (400, 150)), 'blue')

Середина буквы «М»

20) draw.line(((650, 300), (650, 0)), 'magenta', 20) draw.line(((600, 150), (650, 150)), 'green', 20)

И сохраним получившийся результат

new_image.save('name.png')

для работы со звуком

папке с программами и называется image.jpg

y = im.size for i in range(x): for j in range(y): r, g, b = pixels[i, j] bw = (r + g + b) // 3 pixels[i, j] = bw, bw, bw im.save('reы.jpg')

Черно-белое изображение содержит только информацию о яркости, но не о цветах. У таких изображений все три компоненты имеют одинаковое значение, поэтому мы можем просто «размазать» суммарную яркость пикселя поровну по трём компонентам.

in range(y): r, g, b = pixels[i, j] pixels[i, j] = r, b, g

Для значения х негативом будет 255 - x

✔

for i in range(x): for j in range(y): r, g, b = pixels[i, j] pixels[i, j] = 255 - r, 255 - g, 255 - b

Он позволяет задать функцию, меняющую яркость всего пикселя или отдельной компоненты в зависимости от исходной яркости. Изначально эта функция представляет собой прямую y=x.

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

g + b if brightness < 60: k = 60 / brightness return min(255, int(r * k ** 2)), \ min(255, int(g * k ** 2)), \ min(255, int(b * k ** 2)) else: return r, g, b

for i in range(x): for j in range(y): pixels[i, j] = curve(pixels[i, j])

Изменения в теле программы

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

Сырые аудиоданные представляет собой зависимость амплитуды звукового сигнала от времени. Вдоль оси абсцисс откладывается время, вдоль оси ординат — амплитуда (интенсивность, громкость) звукового сигнала.

График строится по точкам, причём вместо пар (t, y) хранятся только значения y, а ось абсцисс задана частотой дискретизации (количеством отсчетов в секунду) — как правило, она составляет 44 100 Гц.

есть проигрывать задом наперед

Будем открывать два файла: исходный — source и формируемый — dest.

Это чем-то похоже на структуры в С. В примере со звуковыми волнами значение y хранится как знаковое двухбайтное число.

Используем возможности встроенного модуля struct. Пока договоримся, что функции этого модуля могут на лету распаковывать и запаковывать данные разной природы.

фреймов frames_count = source.getnframes() data = struct.unpack("<" + str(frames_count) + "h", source.readframes(frames_count)) # собственно, основная строка программы - переворот списка newdata = data[::-1] newframes = struct.pack("<" + str(len(newdata)) + "h", *newdata) # записываем содержимое в преобразованный файл. dest.writeframes(newframes) source.close() dest.close()

вдвое. При этом частота тоже вырастет в два раза.
Если увеличить все фреймы в какое-то количество раз, то произведение станет громче, а если уменьшим — тише.
Копируя каждый фрейм 2 раза, замедлим воспроизведение и понизим частоту.

На телевидении и радио часто ускоряют видео и аудио на 5-10%: это незаметно для уха, но позволяет разместить больше рекламы в эфире.

☼

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

Каждая клетка имеет 8 соседей (сверху, снизу, справа, слева и по диагонали). Клетка может иметь два состояния: живая (на клетке стоит фишка) и мёртвая (фишки нет).

Пространство «Жизни» — бесконечное поле клеток.

В 1970 году Джон Конвей придумал игру «Жизнь» («Genesis»), основанную на клеточном автомате, ставшую довольно популярной и повлиявшую на назвитие многих точных наук.

Джон Хортон Конвей
(род. 26 декабря 1937)

или 3 соседа. Если соседей 4, 5, 6, 7 или 8, то она умирает от перенаселённости, а если 0 или 1 — то от одиночества.
Новая клетка рождается в поле, у которого есть ровно 3 соседа.

Время дискретно и считается поколениями.
Всё начинается с начальной расстановки фишек (0 поколение), в дальнейшем рассматривается эволюция клеточного пространства в 1, 2, 3 и т. д. поколении.
Процессы смерти и рождения происходят одновременно, после чего строится следующее поколение.

Игра прекращается, если:
на поле не останется ни одной «живой» клетки;
конфигурация на очередном шаге в точности (без сдвигов и поворотов) повторит себя же на одном из более ранних шагов (складывается периодическая конфигурация);
при очередном шаге ни одна из клеток не меняет своего состояния (складывается стабильная конфигурация: предыдущее правило, вырожденное до одного шага назад)

0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8)

Заданим поле 10 x 10, в центр которого поместим конструкцию, известную как «глайдер»

Поле имеет тип uint8, чтобы оно занимало меньше памяти. Каждый его элемент занимает ровно 1 байт (8 бит) и является целым беззнаковым (unsigned) числом в диапазоне от 0 до 255.

Живые клетки обозначаются единицей, а мёртвые — нулём.

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

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

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

new_generation = np.roll(population, 2, 0)

Например, вот так можно сдвинуть исходный массив на две строки вниз

Было

Стало

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

new_generation = np.roll(population, 2, 1)

Было

Стало

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

Правильно, на два столбца вправо

✔

со сдвигом массива и просуммировав их

neighbors = sum([ np.roll(np.roll(population, -1, 1), 1, 0), np.roll(np.roll(population, 1, 1), -1, 0), np.roll(np.roll(population, 1, 1), 1, 0), np.roll(np.roll(population, -1, 1), -1, 0), np.roll(population, 1, 1), np.roll(population, -1, 1), np.roll(population, 1, 0), np.roll(population, -1, 0) ])

[[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 1 1 1 0 0 0 0]
[0 0 0 1 1 2 1 0 0 0]
[0 0 1 3 5 3 2 0 0 0]
[0 0 1 1 3 2 2 0 0 0]
[0 0 1 2 3 2 1 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]]

Матрица соседей

соседа, то в следующем поколении на этом месте будет клетка; а если 2 соседа, то клетка будет при условии, что она была "жива" в текущем поколении».
Для этого воспользуемся операторами | (или) и & (и).

[[False False False False False False False False False False]
[False False False False False False False False False False]
[False False False False False False False False False False]
[False False False False False False False False False False]
[False False False True False True False False False False]
[False False False False True False False False False False]
[False False False False True False False False False False]
[False False False False False False False False False False]
[False False False False False False False False False False]
[False False False False False False False False False False]]

neighbors == 3

Имеется три соседа

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

эти два условия

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

next_population()

def next_population(population): neighbors = sum([ np.roll(np.roll(population, -1, 1), 1, 0), np.roll(np.roll(population, 1, 1), -1, 0), np.roll(np.roll(population, 1, 1), 1, 0), np.roll(np.roll(population, -1, 1), -1, 0), np.roll(population, 1, 1), np.roll(population, -1, 1), np.roll(population, 1, 0), np.roll(population, -1, 0) ]) return (neighbors == 3) | (population & (neighbors == 2))

for _ in range(4): print(population, '\n') population = next_population(population)

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

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

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

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

Глайдер «летит»: каждые четыре поколения он сдвигается вниз и вправо. Иными словами, он движется в правый нижний угол

вывод или output.txt

На рисунке показано несколько поколений одномерного клеточного автомата. У каждой клетки только два соседа — слева и справа, а поле представляет собой бесконечную полосу клеток (правый сосед последней клетки – это первая клетка, а левый сосед первой клетки – последняя). Эволюция идёт сверху вниз: первое поколение приведено в верхней строчке, второе — во второй сверху и т.д.

поколения определяется сочетанием цветов трёх соседних ячеек предыдущего поколения, расположенных над ней: непосредственно сверху и по диагоналям (сверху-слева и сверху-справа).
Всего возможны восемь разных «триплетов», порождающих в следующем поколении либо закрашенную ячейку (1), либо пустую (0). Это дает 256 возможных правил эволюции. В этой задаче используется правило номер 30.
Используя библиотеку numpy, напишите функцию generation(line), которая вычисляет и возвращает десятое поколение клеточного автомата по правилу 30.

0, 0): 0, (0, 0, 1): 1, (0, 1, 0): 1, (0, 1, 1): 1, (1, 0, 0): 1, (1, 0, 1): 0, (1, 1, 0): 0, (1, 1, 1): 0, }

Правила клеточного автомата оформим в виде словаря. Ключом будет кортеж, состоящий из клеток - соседей предыдущего поколения, элементом – текущее состояние клетки. 0 – белая клетка, 1 – черная.

len(s)

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

for i in range(10):

Нам нужно десятое поколение клеточного автомата, поэтому вычисления повторятся в цикле соответствующее число раз