Шпаргалки/Справочник — PYTHON

Python — идеальный инструмент для любой проблемы

Вадим В. Костерин — Sun, 29 Sep 2019 05:30:13 +0000

Размышления о моей первой программе на Python.

Размышления это всегда помогающее (а иногда и развлекающее) занятие. Из ностальгических соображений, конечно, если можно испытывать ностальгию по чему-то, что было два года назад — я хочу поделиться моей программой на Python. Изначально я начал работать с Python, когда был ещё студентом и изучал аэрокосмическую технику. Используя Python, я хотел избежать работ с электронными таблицами. Тогда я ещё не подозревал, насколько хорошее решение я принял.

Моё изучение Python началось с книги «Автоматизация рутинных задач с помощью Python» (в оригинале «Automate the Boring Stuff with Python») Эла Свейгарта. Великолепная приложение-ориентированная книга с простыми программами, которые делают полезные вещи. Когда я изучаю что-то новое, я ищу любую возможность использовать свои новые знания, поэтому я хотел найти проблему, которую я мог бы решить с помощью Python. Такой проблемой стал учебник для класса, который стоил 200 долларов. Мой персональный лимит для учебника около 20 долларов («Автоматизация рутинных задач с помощью Python» бесплатна в онлайне), поэтому я отказался даже арендовать эту книгу. Отчаявшись получить книгу к своему первому занятию, я заметил, что её можно получить в свободное пользование на неделю через Amazon, сделав новый аккаунт. Я получил книгу на одну неделю и смог выполнить своё первое учебное занятие. И пока я продолжал создавать новые аккаунты каждую неделю, я понимал, что мне нужно решение получше. Именно так я и решил создать своё первое приложение на Python.

Одной из многих полезных библиотек, описанных в «Автоматизация рутинных задач с помощью Python», являлась PyAutoGUI, которая позволяет контролировать мышь и клавиатуру через Python. Как говорится, «когда у тебя есть молоток, то каждая проблема выглядит как гвоздь», и это было идеальное описание моей ситуации. Python и PyAutoGUI позволили мне нажимать стрелки на клавиатуре и делать скриншоты, и я использовал обе эти возможности чтобы решить свою книжную проблему. Я написал свою первую программу, чтобы автоматически пролистать каждую страницу книги и сделать скриншот. В программе всего 10 строк кода, но я горжусь ими настолько же, насколько горжусь всем, что я сделал в аэрокосмической технике. Далее пример всего кода, что я написал:

import pyautogui
import time

# Sleep for 5 seconds to allow me to open book
time.sleep(5)

# Range can be changed depending on the number of pages
for i in range(1000):
# Turn page
     pyautogui.keyDown('right')
     pyautogui.keyUp('right')

# Take and save a screenshot
     pyautogui.screenshot('images/page_%d.pdf' % i)
     time.sleep(0.05)

Запустить программу очень просто (и я настаиваю каждому попробовать). Я сохранил скрипт как book_screenshot.py, затем переместился в командой строке в ту же директорию, где лежит этот файл, и ввёл:

python book_screenshot.py

После запуска у меня есть 5 секунд, чтобы развернуть книгу в полный экран. Программа же сделает всё остальное, пролистав каждую страницу и сделав скриншот, который сохранится в pdf. После я смогу объединить все pdf-файлы в один и получить (сомнительно легальную) полноценную копию книги! Правда, копия ужасная, ведь через скриншоты нельзя сделать поиск по тексту, но для меня это было не так важно.

Программа же сделает всё остальное, пролистав каждую страницу и сделав скриншот, который сохранится в pdf

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

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

Всего с парой строк кода и бесплатной книгой я смог написать программу, которая по-настоящему полезна. Учить базовые вещи может быть скучно и мои первые попытки учить Python потерпели крах спустя пару часов, когда я читал про структуры данных и циклы. Сменив тактику, я начал создавать решения для реальных проблем и выучил фундаментальные знания параллельно. Программирование очень объёмно, но вам не нужно учить всё и сразу. Просто найдите проблему, которую вы бы хотели решить с помощью программирования и начните!

С тех пор я сделал ещё пару сложных программ, но до сих пор с любовью вспоминаю свой первый скрипт!

Перевод статьи William Koehrsen: Python is the Perfect Tool for any Problem

Дзен Python на русском

Вадим В. Костерин — Mon, 30 Sep 2019 06:20:03 +0000

Разработчики языка Python придерживаются определённой философии программирования, называемой «The Zen of Python» («Дзен Питона», или «Дзен Пайтона»). Её текст выдаётся интерпретатором Python по команде import this (работает один раз за сессию).

В целом она подходит к программированию на любом языке.

Текст философии

Красивое лучше, чем уродливое.
Явное лучше, чем неявное.
Простое лучше, чем сложное.
Сложное лучше, чем запутанное.
Плоское лучше, чем вложенное.
Разреженное лучше, чем плотное.
Читаемость имеет значение.
Особые случаи не настолько особые, чтобы нарушать правила.
При этом практичность важнее безупречности.
Ошибки никогда не должны замалчиваться.
Если они не замалчиваются явно.
Встретив двусмысленность, отбрось искушение угадать.
Должен существовать один и, желательно, только один очевидный способ сделать это.
Хотя он поначалу может быть и не очевиден, если вы не голландец [^1].
Сейчас лучше, чем никогда.
Хотя никогда зачастую лучше, чем прямо сейчас.
Если реализацию сложно объяснить — идея плоха.
Если реализацию легко объяснить — идея, возможно, хороша.
Пространства имён — отличная штука! Будем делать их больше!

Автор этой философии — Тим Петерс. Оригинал на английском:

λ python
Python 3.6.2 (v3.6.2:5fd33b5, Jul  8 2017, 04:14:34) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Заряжаем свой компьютер

Вадим В. Костерин — Mon, 30 Sep 2019 06:22:59 +0000

На сегодняшний день активно эксплуатируются две версии Python — это Python 2 и Python 3, у них отсутствует полная совместимость друг с другом. На момент написания статьи вторая версия Python ещё широко используется, но, судя по изменениям, которые происходят, со временем, он останется только для того, чтобы запускать старый код. В нашей с вами работе, мы будем использовать Python 3, и, в дальнейшем, если где-то будет встречаться слово Python, то под ним следует понимать Python 3. Случаи применения Python 2 будут специально оговариваться.

1. Установка Python

Для установки интерпретатора Python на ваш компьютер, первое, что нужно сделать — это скачать дистрибутив. Загрузить его можно с официального сайта https://www.python.org/downloads/

Для операционной системы Windows дистрибутив распространяется либо в виде исполняемого файла (с расширением exe), либо в виде архивного файла (с расширением zip). Если вы используете Windows 7, не забудьте установить Service Pack 1!

Порядок установки.

1. Запустите скачанный установочный файл.

2. Выберет способ установки.

Установка Python. Делай раз

В этом окне предлагается два варианта Install Now и Customize installation. При выборе Install Now, Python установится в папку по указанному пути. Помимо самого интерпретатора будет установлен IDLE (интегрированная среда разработки), pip (пакетный менеджер) и документация, а также будут созданы соответствующие ярлыки и установлены связи файлов, имеющие расширение .py с интерпретатором Python. Customize installation – это вариант настраиваемой установки. Опция Add python 3.5 to PATH нужна для того, чтобы появилась возможность запускать интерпретатор без указания полного пути до исполняемого файла при работе в командной строке.

3. Отметьте необходимые опций установки (доступно при выборе Customize installation)

Установка Python. Делай два

На этом шаге нам предлагается отметить дополнения, устанавливаемые вместе с интерпретатором Python. Рекомендуем выбрать все опции.

Documentation – установка документаций.
pip – установка пакетного менеджера pip.
tcl/tk and IDLE – установка интегрированной среды разработки (IDLE) и библиотеки для построения графического интерфейса (tkinter).

4. Выберете место установки (доступно при выборе Customize installation)

Выбор места установки Python

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

Install for all users – Установить для всех пользователей. Если не выбрать данную опцию, то будет предложен вариант инсталляции в папку пользователя, устанавливающего интерпретатор.
Associate files with Python – Связать файлы, имеющие расширение .py, с Python. При выборе данной опции будут внесены изменения в Windows, позволяющие запускать Python скрипты по двойному щелчку мыши.
Create shortcuts for installed applications – Создать ярлыки для запуска приложений.
Add Python to environment variables – Добавить пути до интерпретатора Python в переменную PATH.
Precomple standard library – Провести прекомпиляцию стандартной библиотеки.

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

5. После успешной установки вас ждет следующее сообщение.

Все хорошо. Python готов к работе

2. Проверка работоспособности

Теперь проверим работоспособность всего того, что мы установили.

2.1 Проверка интерпретатора Python

Для начала протестируем интерпретатор в командном режиме. Если вы работаете в Windows, то нажмите сочетание Win + R и в появившемся окне введите python. В Linux откройте окно терминала и в нем введите python3 (или python).

В результате Python запустится в командном режиме, выглядеть это будет примерно так (картинка приведена для Windows, в Linux результат будет аналогичным):

Запустим интерпретатор Python

В окне введите:

print(“Hello, World!”)

Результат должен быть следующий:

Сделаем что-нибудь с Python

2.2 Проверка интегрированной учебной среды IDLE

О том как проверить и работать с интегрированной учебной средой IDLE можно подробнее прочитать в статье Быстрый старт с IDLE Python

Python конспективно за 15 минут

Вадим В. Костерин — Mon, 30 Sep 2019 06:23:07 +0000

Итак, вы хотите выучить язык программирования Python, но не может найти краткий и в то же полнофункциональный учебник. С помощью этой статьи мы попытаемся научить вас программировать на Python в течении 10 минут. Это, вероятно, не столько учебник, сколько нечто среднее между обзором основных возможностей и шпаргалкой, так что мы будем просто показывать вам некоторые основные понятия, чтобы вы могли начать программировать на Python сразу после прочтения статьи. Представленные здесь коды рекомендуется скопировать в редактор IDLE Python и немедленно проверять по ходу пьесы.

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

Свойства языка

Python является строго типизированным языком (т.е. обладает типобезопасностью), но, в тоже время, и динамически, неявно типизированным (т.е. вы не должны объявлять переменные). Кроме того, Python чувствителен к регистру (то есть var и VAR — две разные переменные) и объектно-ориентирован (т.е. всё в Python — объект: числа, словари, пользовательские и встроенные классы).

Help!

Помощь в Python всегда доступен прямо в интерпретаторе. Если вы хотите знать, как работает какой-либо объект, все, что вам нужно сделать, это выполнить help()! Также полезна команда dir(), которая показывает все методы объекта, а .__ doc__, показывает строку документации для объекта:

>>> help(5)
Help on int object:
(etc etc)
 
>>> dir(5)
[‘__abs__’, ‘__add__’, ...]
 
>>> abs.__doc__
‘abs(number) -> number
 
Return the absolute value of the argument.’

Ключевые слова Python

Ключевое слово Python — это уникальный программный термин, предназначенный для выполнения какого-либо действия. В Python насчитывается до 33 таких ключевых слов, каждое из которых служит своей цели. Вместе они создают словарный запас языка Python. Словарный запас Эллочки-людоедочки из «12 стульев» Ильфа и Петрова больше!

Они представляют синтаксис и структуру программы Python. Так как все они зарезервированы, вы не можете использовать их имена для определения переменных, классов или функций.

Все ключевые слова в Python чувствительны к регистру. Таким образом, вы должны быть осторожны при использовании их в своем коде. Мы только что сделали снимок возможных ключевых слов Python. Попробуйте в консоли Python набрать следующий код:

>>> words = keyword.kwlist
>>> words
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>> len(words)
33

Всего 33 слова надо запомнить. Вот здесь о них поробнее:

False — Ложь
None — Пусто
True — Истина
and — И
as — менеджер контекста
assert <условие> — возбуждает исключение при ложном значении условия
break — прервать
class — пользовательский тип данных, включающий атрибуты и методы манипулирования ими
continue — продолжить
def — определение функции
del — удаление объекта
elif — элемент конструкции выбора
else — элемент конструкции выбора
except — элемент конструкции исключений
finally — элемент конструкции исключений
for — цикл с известным количеством повторений
from — импорт функций из пакета
global — описание глобальной переменной внутри функии
if — элемент конструкции выбора
import — импорт пакета
in — включение
is — принадлежность
lambda — описание лямбда-фунции
nonlocal —
not — логическое отрицание НЕТ
or — логическое ИЛИ
pass — пусто, заглушка
raise — элемент конструкции исключений
return — возврат в вызывающую функцию
try — элемент конструкции исключений
with — менеджер контекста
while — цикл с неизвестным количеством повторений
yield — элемент конструкции исключений

Синтаксис

Python не имеет обязательных символов завершения оператора, а границы блоков определяются отступами. Отступ начинает новый блок, отсутсвие отступа его заканчивает. Выражения, которые ожидают после себя новый отступ заканчиваются символом двоеточия (:). Однострочные комментарии начинаются с символа фунта (#), для многострочных комментариев используются строковые литералы, заключенные в тройные апострофы или тройные кавычки. Значения присваиваются (на самом деле, объекты связанные с именами значений) с помощью знака равенства («=»), а проверка равенства осуществляется с помощью двух знаков равенства («==»). Вы можете увеличивать/уменьшать значения при помощи операторов += и -= соответственно на величину, указанную справа от оператора. Это работает для многих типов данных, в т.ч. и строк. Вы можете также использовать несколько переменных в одной строке. Например:

>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4

"""Это многострочный комментарий.
Он содержит две строки """

>>> mystring = "Hello"
>>> mystring += " world."
>>> print mystring
Hello world.

# Здесь переменные меняет местами и код записан в одной строке (!).
# Строга типизация не нарушается так, как фактически значения
# не назначается, а новые объекты просто связываются со
# старыми именами.
>>> myvar, mystring = mystring, myvar

Типы данных

В Python доступны следующие структуры данных: списки (lists), кортежи (tuples) и словари (dictionaries). Наборы доступны в библиотеке sets (но, она встроенна только в Python 2.5 и более поздние версии). Списки похожи на одномерные массивы (но вы также можете создавать списки, состоящие из других списков и получить многомерный массив), словари — ассоциативные массивы (так называемые хэш-таблицы, индексом в которых может быть любой тип данных), а кортежи представляют собой неизменяемые одномерные массивы (в Python «массивы» могут быть любого типа, так что вы можете смешивать например, целые числа, строки и т.д. в списках/словарях/кортежах). Индексом первого элемента в массивах всех типов является 0, а последний элемент можно получить по индексу -1. Переменные могут указывать на функции. Использование описанных типов данных выглядит следующим образом:

>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again" # Здесь происходит изменение элемента 0.
>>> mylist[—1] = 3.21 # Здесь вы назначаете последнему элементу списка значение 3.21
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15 # Здесь вы изменяете значение элемента словаря. 
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print myfunction(mylist)
3

Вы можете работать только с частью элементов массива используя двоеточие (:). В таком случае, индекс до двоеточия указывает на первый элемент используемой части массива, а индекс после двоеточия — на элемент идущий ПОСЛЕ последнего элемента используемой части массива (он в подмассив не включается). Если первый индекс не указан — используется первый элемент массива, если не указан второй — последним элементом будет последний элемент массива. рассчитывать Отрицательные значения определяют положение элемента с конца. Пример:

>>> mylist = ["List item 1", 2, 3.14]
>>> print mylist[:]
[‘List item 1’, 2, 3.1400000000000001]
>>> print mylist[0:2]
[‘List item 1’, 2]
>>> print mylist[—3:—1]
[‘List item 1’, 2]
>>> print mylist[1:]
[2, 3.14]
# Добавляя третий параметр «шаг» для вывода элементов списка
# Теперь индекс увеличивается не 1, как это принято в Python.
# Например, здесь будет напечатан первый элемент, затем третий (элементы 0 и 2, отсчет индекса начинается с 0).
>>> print mylist[::2]
[‘List item 1’, 3.14]

Строки

Cтроки в Python ограничиваются как одиночными так и двойными кавычки, и вы можете использовать одинарные кавычки внутри строки, которая ограничена двойными кавычками и наоборот (т.е. "Он сказал ‘привет’." и на экран будет выедено "Он сказал ‘привет’!"). Многострочные строки ограничиваются в тремя двойными (""") или тремя одиночными (''') кавычками. Python поддерживает Unicode из коробки, используя вот такой синтаксис: u"Это строка Unicode". Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом, например, так:

>>>print("Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-")
Name: Poromenos
Number: 3
String: ——
 
strString = """Это есть
многострочная 
строка""
 
# ВНИМАНИЕ: Остерегайтесь концевых s в "%(key)s".
>>> print("This %(verb)s a %(noun)s." %{"noun": "test", "verb": "is"}
This is a test.

Операторы управления потоком исполнения

В Python операторы управления потоком данных представленны операторам if, for и while. В Python нет оператора switch; вместо этого следует использовать оператор if. Использование для перечисления через членов списка. Чтобы получить список цифр до числа — используйте функцию range(). Вот пример использования операторов:

rangelist = range(10)
>>> print rangelist
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in rangelist:
    # Check if number is one of
    # the numbers in the tuple.
    if number in (3, 4, 7, 9):
        # «Break» terminates a for without
        # executing the «else» clause.
        break
    else:
        # «Continue» starts the next iteration
        # of the loop. It’s rather useless here,
        # as it’s the last statement of the loop.
        continue
else:
    # The «else» clause is optional and is
    # executed only if the loop didn’t «break».
    pass # Do nothing
 
if rangelist[1] == 2:
    print «The second item (lists are 0-based) is 2»
elif rangelist[1] == 3:
    print «The second item (lists are 0-based) is 3»
else:
    print «Dunno»
 
while rangelist[1] == 1:
    pass

Функции

Для объявления функции используется ключевое слово def. Аргументы функции задаются в скобках после названия функции. Необязательные аргументы задаются в объявлении функции после обязательных аргументов путем присваивается необязательным аргументам значения по умолчанию. Функции могут возвращать кортежи (и с помощью кортежа вы можете эффективно возвращать из функции несколько значений). Лямбда-функции — это специальные функции, которые состоят из одного оператора. Параметры передаются по ссылке, но значения неизменяемых типов (кортежей, строк и т.д.) всё равно не может быть изменены внутри функции. Например:

# Same as def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print funcvar(1)
2
 
# an_int and a_string are optional, they have default values
# if one is not passed (2 and «A default string», respectively).
def passing_example(a_list, an_int=2, a_string=«A default string»):
    a_list.append(«A new item»)
    an_int = 4
    return a_list, an_int, a_string
 
>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print passing_example(my_list, my_int)
([1, 2, 3, ‘A new item’], 4, «A default string»)
>>> my_list
[1, 2, 3, ‘A new item’]
>>> my_int
10

Классы

Python поддерживает ограниченную форму множественного наследования с использованием классов. Внутренние переменные и методы могут быть объявлены (по соглашению, это не является требованием самого языка) путем добавления по меньшей мере, двух начальных символов подчеркивания и не более чем одного завершающего (например, «__spam»). Мы можем также присвоить значение переменной класса извне. Это видно в следующем примере:

class MyClass(object):
    common = 10
    def __init__(self):
        self.myvariable = 3
    def myfunction(self, arg1, arg2):
        return self.myvariable
 
    # This is the class instantiation
>>> classinstance = MyClass()
>>> classinstance.myfunction(1, 2)
3
# This variable is shared by all instances.
>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Note how we use the class name
# instead of the instance.
>>> MyClass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# This will not update the variable on the class,
# instead it will bind a new object to the old
# variable name.
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> MyClass.common = 50
# This has not changed, because «common» is
# now an instance variable.
>>> classinstance.common
10
>>> classinstance2.common
50
 
# This class inherits from MyClass. The example
# class above inherits from «object», which makes
# it what’s called a «new-style class».
# Multiple inheritance is declared as:
# class OtherClass(MyClass1, MyClass2, MyClassN)
class OtherClass(MyClass):
    # The «self» argument is passed automatically
    # and refers to the class instance, so you can set
    # instance variables as above, but from inside the class.
    def __init__(self, arg1):
        self.myvariable = 3
        print arg1
 
>>> classinstance = OtherClass(«hello»)
hello
>>> classinstance.myfunction(1, 2)
3
# This class doesn’t have a .test member, but
# we can add one to the instance anyway. Note
# that this will only be a member of classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

Исключения

Исключения в Python обрабатываются с помощью блоков try-except [exceptionname]:

def some_function():
    try:
        # Division by zero raises an exception
        10 / 0
    except ZeroDivisionError:
        print «Oops, invalid.»
    else:
        # Exception didn’t occur, we’re good.
        pass
    finally:
        # This is executed after the code block is run
        # and all exceptions have been handled, even
        # if a new exception is raised while handling.
        print «We’re done with that.»
 
>>> some_function()
Oops, invalid.
We‘re done with that.

Импорт

Внешние библиотеки загружаются с помощью ключевого слова import [libname]. Вы можете также использовать from [libname] import [funcname] для отдельных функций. Вот пример:

import random
from time import clock
 
randomint = random.randint(1, 100)
>>> print randomint
64

Чтение/запись файлов

Python имеет широкий спектр встроенных библиотек. Например, вот как выполняется сериализация (преобразование структуры данных в строки с помощью библиотеки pickle) с использованием записи/чтения файлов:

import pickle
mylist = [«This», «is», 4, 13327]
# Open the file C:\\binary.dat for writing. The letter r before the
# filename string is used to prevent backslash escaping.
myfile = open(r«C:\\binary.dat», «w»)
pickle.dump(mylist, myfile)
myfile.close()
 
myfile = open(r«C:\\text.txt», «w»)
myfile.write(«This is a sample string»)
myfile.close()
 
myfile = open(r«C:\\text.txt»)
>>> print myfile.read()
‘This is a sample string’
myfile.close()
 
# Open the file for reading.
myfile = open(r«C:\\binary.dat»)
loadedlist = pickle.load(myfile)
myfile.close()
>>> print loadedlist
[‘This’, ‘is’, 4, 13327]

Особенности

Условия могут комбинироваться. Например, 1 < а < 3 проверяет, что a одновременно меньше 3 и больше 1.
Вы можете использовать del для удаления переменных или элементов в массивах.
Python предлагает большие возможности для работы со списками. Вы можете использовать операторы объявления структуры списка. Оператор for позволяет задавать элементы списка в определенной последовательности, а if — позволяет выбирать элементы по условию, например, так:

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print [x * y for x in lst1 for y in lst2]
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print [x for x in lst1 if 4 > x > 1]
[2, 3]
# Check if a condition is true for any items.
# «any» returns true if any item in the list is true.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# This is because 4 % 3 = 1, and 1 is true, so any()
# returns True.
 
# Check for how many items a condition is true.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print lst1
[2, 3]
>>> del lst1

Глобальные переменные объявляются вне функций и могут быть прочитаны без каких-либо специальных объявлений, но если вы хотите, изменить значение глобальной переменной из функции, нужно объявить их в начале функции используя ключевое слово global, в противном случае Python будет считать эту переменную новой локальной переменной. Например:

number = 5
 
def myfunc():
    # This will print 5.
    print number
 
def anotherfunc():
    # This raises an exception because the variable has not
    # been bound before printing. Python knows that it an
    # object will be bound to it later and creates a new, local
    # object instead of accessing the global one.
    print number
    number = 3
 
def yetanotherfunc():
    global number
    # This will correctly change the global.
    number = 3

Заключение

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

Практикум №1 — набиваем руку

Вадим В. Костерин — Tue, 01 Oct 2019 01:34:52 +0000

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

В курсе «Программирование» на Бизнес-информатике предлагается всего лишь 101 задача, которые приведены ниже, для упражнений на Phyton и каждому необходимо решить самостоятельно.

Решение всех задач хотелось бы видеть в вашем репозитарии на Github

Задачи для самостоятельной работы

Линейные алгоритмы

Нарисуйте блок-схему к следующей задаче: Преобразовать дату в «компьютерном» представлении (системную дату) в «российский» формат, т.е. день/месяц/год (например, 17/05/2009).
Постановка задачи: Системная дата имеет вид 2009-06-15. Нужно преобразовать это значение в строку, строку разделить на компоненты (символ→разделитель→дефис), потом из этих компонентов сконструировать нужную строку.
Даны действительные числа $А, В, С$ . Найти максимальное и минимальное из этих чисел.
Известны длины трёх сторон треугольника. Вычислить периметр треугольника и площадь по формуле Герона (указание: использовать модуль math и функцию sqrt ()).
Задан вес в граммах. Определить вес в тоннах и килограммах.
Известен объем информации в байтах. Перевести в килобайты, мегабайты.
Определить значение функции $Z = \frac{1}{(XY)}$ при $X$ и $Y$ не равных $0$ .

Ветвления и оператор выбора

Дано натуральное число. Определить, будет ли это число: чётным, кратным 4.
Дано натуральное число. Определить, будет ли это число: нечётным, кратным 5.
Дано натуральное число. Определить, будет ли это число: нечётным, кратным 7.
Дано натуральное число. Определить, будет ли это число: чётным, кратным 10.
Имеется коробка со сторонами: $A \times B \times C$ . Определить, пройдёт ли она в дверь с размерами $M \times K$ .
Дано вещественное число. Определить, какое это число: положительное, отрицательное, ноль.
Можно ли из бревна, имеющего диаметр поперечного сечения $D$ , выпилить квадратный брус шириной $A$ ?
Можно ли в квадратном зале площадью $S$ поместить круглую сцену радиусом $R$ так, чтобы от стены до сцены был проход не менее $K$ ?
Дан номер места в плацкартном вагоне. Определить, какое это место: верхнее или нижнее, в купе или боковое.
Известна денежная сумма. Разменять её купюрами 500, 100, 10 и монетой 2 руб., если это возможно.
Имеются две ёмкости: кубическая с ребром $A$ , цилиндрическая с высотой $H$ и радиусом основания $R$ . Определить, поместится ли жидкость объёма $M$ литров в первую ёмкость, во вторую, в обе.
Имеются две ёмкости: кубическая с ребром $A$ , цилиндрическая с высотой $H$ и радиусом основания $R$ . Определить, можно ли заполнить жидкостью объёма $M$ литров первую ёмкость, вторую, обе.
Даны вещественные числа: $X, Y, Z$ . Определить, существует ли треугольник с такими длинами сторон и если существует, будет ли он прямоугольным.
Дано число $X$ . Определить, принадлежит ли это число заданному промежутку $[a, b]$ .
Определить значение функции $Z = \frac{1}{XY}\text{ при произвольных }X\text{ и }Y$ .
Даны вещественные числа $A, B, C$ . Определить, выполняются ли неравенства $A < B < C\text{ или }A > B > C$ , и какое именно неравенство выполняется.
Даны два вещественных числа $X\text{ и }Y$ . Вычислить $Z = \sqrt{X \times Y}$ при $X > Y, Z = ln{(X + Y)}$ в противном случае.
Даны вещественные положительные числа $a, b, c, d$ . Выясните, может ли прямоугольник со сторонами $a, b$ уместиться внутри прямоугольника со сторонами $c, d$ так, чтобы каждая сторона внутреннего прямоугольника была параллельна или перпендикулярна стороне внешнего прямоугольника.
Дано вещественное число $A$ . Вычислить $f(A)$ , если $f(x) = x^2 + 4x +5$ , при $x \leq 2$ ; в противном случае $f(x) = \frac{1}{x^2 + 4x + 5}$ .
Дано вещественное число $A$ . Вычислить $f(A)$ , если $f(x) = 0$ , при $x \leq 2$ . $f(x) = x$ , при $(x \geq 1)$ , в противном случае $f(x) = x^4$ .
Дано вещественное число $A$ . Вычислить $f(A)$ , если $f(x) = 0$ , при $x \leq 0$ . $f(x) = x^2 - x$ , при $(x \geq 1)$ , в противном случае $f(x) = x^2 - \sin{(\pi x^2)}$ .
Составить алгоритм и программу для реализации логических операций «И» и «ИЛИ» для двух переменных.
Известен ГОД. Определить, будет ли этот год високосным, и к какому веку этот год относится

Указание.

При вычислении корней и логарифмов используйте функции sqrt() и log() модуля math. В этом же модуле определена константа pi (math.pi).

Циклические алгоритмы. Обработка последовательностей и одномерных массивов

Составьте блок-схему поиска максимального элемента в одномерном массиве.
Нарисуйте полную блок-схему алгоритма сортировки массива «методом пузырька».
Дан одномерный массив числовых значений, насчитывающий N элементов. Поменять местами элементы, стоящие на чётных и нечётных местах: A[1] A[2]; A[3] A[4] …
Дан одномерный массив числовых значений, насчитывающий N элементов. Выполнить перемещение элементов массива по кругу вправо, т. е. A[1] → A[2]; A[2] → A[3]; … A[n] → A[1].
Дан одномерный массив числовых значений, насчитывающий N элементов. Поменять местами первую и вторую половины массива.
Дан одномерный массив числовых значений, насчитывающий N элементов. Поменять местами группу из M элементов, начинающихся с позиции K с группой из M элементов, начинающихся с позиции P.
Дан одномерный массив числовых значений, насчитывающий N элементов. Вставить группу из M новых элементов, начиная с позиции K.
Дан одномерный массив числовых значений, насчитывающий N элементов. Сумму элементов массива и количество положительных элементов поставить на первое и второе место.
Дан одномерный массив числовых значений, насчитывающий N элементов.Исключить из него M элементов, начиная с позиции K.
Дан одномерный массив числовых значений, насчитывающий N элементов. Исключить все нулевые элементы.
Дан одномерный массив числовых значений, насчитывающий N элементов. После каждого отрицательного элемента вставить новый элемент, равный квадрату этого отрицательного элемента.
Дан одномерный массив числовых значений, насчитывающий N элементов. Определить, образуют ли элементы массива, расположенные перед первым отрицательным элементом, возрастающую последовательность.
Дан одномерный массив числовых значений, насчитывающий N элементов. Определить, образуют ли элементы массива, расположенные перед первым отрицательным элементом, убывающую последовательность.
Дан одномерный массив числовых значений, насчитывающий N элементов. Из элементов исходного массива построить два новых. В первый должны входить только элементы с положительными значениями, а во второй — только элементы с отрицательными значениями.
Дан одномерный массив числовых значений, насчитывающий N элементов. Добавить столько элементов, чтобы элементов с положительными и отрицательными значениями стало бы поровну.
Дан одномерный массив числовых значений, насчитывающий N элементов. Добавить к элементам массива такой новый элемент, чтобы сумма элементов с положительными значениями стала бы равна модулю суммы элементов с отрицательными значениями.
Дан одномерный массив числовых значений, насчитывающий N элементов. Дано положительное число T. Разделить это число между положительными элементами массива пропорционально значениям этих элементов и добавить полученные доли к соответствующим элементам.
Дан одномерный массив числовых значений, насчитывающий N элементов. Исключить из массива элементы, принадлежащие промежутку [B; C].
Дан одномерный массив числовых значений, насчитывающий N элементов. Вместо каждого элемента с нулевым значением поставить сумму двух предыдущих элементов массива.
Дан одномерный массив числовых значений, насчитывающий N элементов. Определить, имеются ли в массиве два подряд идущих нуля.
Дан одномерный массив числовых значений, насчитывающий N элементов. Подсчитать количество чисел, делящихся на 3 нацело, и среднее арифметическое чисел с чётными значениями. Поставить полученные величины на первое и последнее места в массиве (увеличив массив на 2 элемента).
Заданы M строк символов, которые вводятся с клавиатуры. Найти количество символов в самой длинной строке. Выровнять строки по самой длинной строке, поставив перед каждой строкой соответствующее количество звёздочек.
Заданы M строк символов, которые вводятся с клавиатуры. Из заданных строк, каждая из которых представляет одно слово, составить одну длинную строку, разделяя слова пробелами.
Заданы M строк слов, которые вводятся с клавиатуры. Подсчитать количество гласных букв в каждой из заданных строк.
Заданы M строк слов, которые вводятся с клавиатуры (в каждой строке – одно слово). Вводится слог (последовательность букв). Подсчитать количество таких слогов в каждой строке.
Заданы M строк слов, которые вводятся с клавиатуры (в каждой строке – одно слово). Вводится слог (последовательность букв). Удалить данный слог из каждой строки.
Заданы M строк символов, которые вводятся с клавиатуры. Напечатать все центральные буквы строк нечетной длины.
Заданы M строк символов, которые вводятся с клавиатуры. Каждая строка содержит слово. Записать каждое слово в разрядку (вставить по пробелу между буквами).
Задана строка символов, в которой встречается символ «.». Поставить после каждого такого символа системное время ПК.
Заданы M строк, которые вводятся с клавиатуры. Подсчитать количество пробелов в каждой из строк.
Заданы M строк символов, которые вводятся с клавиатуры. Каждая строка представляет собой последовательность символов, включающих в себя вопросительные знаки. Заменить в каждой строке все имеющиеся вопросительные знаки звёздочками.
Последовательно вводятся числа. Определить сумму чисел с нечётными номерами и произведение чисел с чётными номерами (по порядку ввода). Подсчитать количество слагаемых и количество сомножителей. При вводе числа 55555 закончить работу.
Определить сумму вводимых положительных чисел. Причём числа с нечётными номерами (по порядку ввода) суммировать с обратным знаком, а числа с чётными номерами перед суммированием возводить в квадрат. Подсчитать количество слагаемых. При вводе первого отрицательного числа закончить работу.
Даны число P и число H. Определить сумму чисел меньше P, произведение чисел больше H и количество чисел в диапазоне значений P и H. При вводе числа равного P или H, закончить работу.
Суммировать вводимые числа, среди которых нет нулевых. При вводе нуля обеспечить вывод текущего значения суммы. При вводе числа 99999 закончить работу.
Вводятся положительные числа. Определить сумму чисел, делящихся на положительное число B нацело. При вводе отрицательного числа закончить работу.
Для вводимых чисел определить процент положительных и отрицательных чисел. При вводе числа −65432 закончить работу.

Обработка двумерных массивов (матриц)

Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти наибольший элемент столбца матрицы A, для которого сумма абсолютных значений элементов максимальна.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти наибольшее значение среди средних значений для каждой строки матрицы.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти наименьший элемент столбца матрицы A, для которого сумма абсолютных значений элементов максимальна.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти наименьшее значение среди средних значений для каждой строки матрицы.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Определить средние значения по всем строкам и столбцам матрицы. Результат оформить в виде матрицы из N + 1 строк и M + 1 столбцов.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти сумму элементов всей матрицы. Определить, какую долю в этой сумме составляет сумма элементов каждого столбца. Результат оформить в виде матрицы из N + 1 строк и M столбцов.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти сумму элементов всей матрицы. Определить, какую долю в этой сумме составляет сумма элементов каждой строки. Результат оформить в виде матрицы из N строк и M+1 столбцов.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Определить, сколько отрицательных элементов содержится в каждом столбце и в каждой строке матрицы. Результат оформить в виде матрицы из N + 1 строк и M + 1 столбцов.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Определить, сколько нулевых элементов содержится в верхних L строках матрицы и в левых К столбцах матрицы.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Перемножить элементы каждого столбца матрицы с соответствующими элементами K-го столбца.Аим
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Просуммировать элементы каждой строки матрицы с соответствующими элементами L-й строки.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Разделить элементы каждой строки на элемент этой строки с наибольшим значением.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Разделить элементы каждого столбца матрицы на элемент этого столбца с наибольшим значением.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Разделить элементы матрицы на элемент матрицы с наибольшим значением.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Все элементы имеют целый тип. Дано целое число H. Определить, какие столбцы имеют хотя бы одно такое число, а какие не имеют.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Исключить из матрицы строку с номером L. Сомкнуть строки матрицы.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Добавить к матрице строку и вставить ее под номером L.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Найти сумму элементов, стоящих на главной диагонали, и сумму элементов, стоящих на побочной диагонали (элементы главной диагонали имеют индексы от [0,0] до [N,N], а элементы побочной диагонали – от [N,0] до [0,N]).
Создать квадратную матрицу A, имеющую N строк и N столбцов со случайными элементами. Определить сумму элементов, расположенных параллельно главной диагонали (ближайшие к главной). Элементы главной диагонали имеют индексы от [0,0] до [N,N].
Создать квадратную матрицу A, имеющую N строк и N столбцов со случайными элементами. Определить произведение элементов, расположенных параллельно побочной диагонали (ближайшие к побочной). Элементы побочной диагонали имеют индексы от [N,0] до [0,N].
Создать квадратную матрицу A, имеющую N строк и N столбцов со случайными элементами. Каждой паре элементов, симметричных относительно главной диагонали (ближайшие к главной), присвоить значения, равные полусумме этих симметричных значений (элементы главной диагонали имеют индексы от [0,0] до [N,N]).
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Исходная матрица состоит из нулей и единиц. Добавить к матрице еще один столбец, каждый элемент которого делает количество единиц в каждой строке чётным.
Создать квадратную матрицу A, имеющую N строк и N столбцов со случайными элементами. Найти сумму элементов, расположенных выше главной диагонали, и произведение элементов, расположенных выше побочной диагонали (элементы главной диагонали имеют индексы от [0,0] до [N,N], а элементы побочной диагонали — от [N,0] до [0,N]).
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Дан номер строки L и номер столбца K, при помощи которых исходная матрица разбивается на четыре части. Найти сумму элементов каждой части.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Определить, сколько нулевых элементов содержится в каждом столбце и в каждой строке матрицы. Результат оформить в виде матрицы из N + 1 строк и M + 1 столбцов.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Дан номер строки L и номер столбца K, при помощи которых исходная матрица разбивается на четыре части. Найти среднее арифметическое элементов каждой части.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Все элементы имеют целый тип. Дано целое число H. Определить, какие строки имеют хотя бы одно такое число, а какие не имеют.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Исключить из матрицы столбец с номером K. Сомкнуть столбцы матрицы.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Добавить к матрице столбец чисел и вставить его под номером K.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Добавить к элементам каждого столбца такой новый элемент, чтобы сумма положительных элементов стала бы равна модулю суммы отрицательных элементов. Результат оформить в виде матрицы из N + 1 строк и M столбцов.
Создать прямоугольную матрицу A, имеющую N строк и M столбцов со случайными элементами. Добавить к элементам каждой строки такой новый элемент, чтобы сумма положительных элементов стала бы равна модулю суммы отрицательных элементов. Результат оформить в виде матрицы из N строк и M + 1 столбцов.

Работа с ассоциативными массивами (таблицами данных)

Используя данные таблицы отсортировать блюда по возрастанию цены. Вывести отсортированный вариант списка блюд.

Блюдо

Цена

Борщь

35

Котлета

40

Каша

20

Чай

3
Имеется список учеников и результаты трёх тестов (баллы от 0 до 100).Определить средний балл каждого ученика по трём тестам, вывести список учеников по убыванию среднего балла.
Известны данные о количестве мальчиков и девочек в нескольких классах. Отсортировать названия классов по возрастанию процента мальчиков, определить количество классов, в которых мальчиков больше, чем девочек, и вывести названия этих классов отдельно.
Решить задачу, связанную с оценкой экономической деятельности группы предприятий на основе известных данных:
- название предприятий;
- плановый объем розничного товарооборота;
- фактический объем розничного товарооборота.
Требуется определить:
1. процент выполнения плана каждым предприятием;
2. количество предприятий, недовыполнивших план на 10% и более;
3. наименьший плановый товарооборот;
4. упорядочить предприятия по убыванию планового товара.

Как оформлять код

Вадим В. Костерин — Tue, 01 Oct 2019 01:35:18 +0000

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

PEP 8 (Python Enhancement Proposals, англ. или предложения по улучшению Python, рус.) создан на основе рекомендаций Гуидо ван Россума с добавлениями от Барри. Если где-то возникал конфликт, мы выбирали стиль Гуидо. И, конечно, этот PEP может быть неполным (фактически, он, наверное, никогда не будет закончен).

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

Это руководство о согласованности и единстве. Согласованность с этим руководством очень важна. Согласованность внутри одного проекта еще важнее. А согласованность внутри модуля или функции — самое важное. Но важно помнить, что иногда это руководство неприменимо, и понимать, когда можно отойти от рекомендаций. Когда вы сомневаетесь, просто посмотрите на другие примеры и решите, какой выглядит лучше.

Две причины для того, чтобы нарушить данные правила:

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

Содержание

Внешний вид кода
Пробелы в выражениях и инструкциях
- Избегайте использования пробелов в следующих ситуациях:
- Другие рекомендации
Комментарии
Контроль версий
Соглашения по именованию
Общие рекомендации

Внешний вид кода

Отступы

Используйте 4 пробела на каждый уровень отступа.

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

Правильно:

# Выровнено по открывающему разделителю
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

# Больше отступов включено для отличения его от остальных
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

Неправильно:

# Аргументы на первой линии запрещены, если не используется вертикальное выравнивание
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Больше отступов требуется, для отличения его от остальных
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)

Опционально:

# Нет необходимости в большем количестве отступов.
foo = long_function_name(
  var_one, var_two,
  var_three, var_four)

Закрывающие круглые/квадратные/фигурные скобки в многострочных конструкциях могут находиться под первым непробельным символом последней строки списка, например:

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )

либо быть под первым символом строки, начинающей многострочную конструкцию:

my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
)

Табуляция или пробелы?

Пробелы — самый предпочтительный метод отступов.

Табуляция должна использоваться только для поддержки кода, написанного с отступами с помощью табуляции.

Python 3 запрещает смешивание табуляции и пробелов в отступах.

Python 2 пытается преобразовать табуляцию в пробелы.

Когда вы вызываете интерпретатор Python 2 в командной строке с параметром -t, он выдает предупреждения (warnings) при использовании смешанного стиля в отступах, а запустив интерпретатор с параметром -tt, вы получите в этих местах ошибки (errors). Эти параметры очень рекомендуются!

Максимальная длина строки

Ограничьте длину строки максимум 79 символами.

Для более длинных блоков текста с меньшими структурными ограничениями (строки документации или комментарии), длину строки следует ограничить 72 символами.

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

Некоторые команды предпочитают большую длину строки. Для кода, поддерживающегося исключительно или преимущественно этой группой, в которой могут прийти к согласию по этому вопросу, нормально увеличение длины строки с 80 до 100 символов (фактически увеличивая максимальную длину до 99 символов), при условии, что комментарии и строки документации все еще будут 72 символа.

Стандартная библиотека Python консервативна и требует ограничения длины строки в 79 символов (а строк документации/комментариев в 72).

Предпочтительный способ переноса длинных строк является использование подразумеваемых продолжений строк Python внутри круглых, квадратных и фигурных скобок. Длинные строки могут быть разбиты на несколько строк, обернутые в скобки. Это предпочтительнее использования обратной косой черты для продолжения строки.

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

with open('/path/to/some/file/you/want/to/read') as file_1, \
        open('/path/to/some/file/being/written', 'w') as file_2:
    file_2.write(file_1.read())

Ещё один случай — assert.

Сделайте правильные отступы для перенесённой строки. Предпочтительнее вставить перенос строки после логического оператора, но не перед ним. Например:

class Rectangle(Blob):

    def __init__(self, width, height,
                 color='black', emphasis=None, highlight=0):
        if (width == 0 and height == 0 and
                color == 'red' and emphasis == 'strong' or
                highlight > 100):
            raise ValueError("sorry, you lose")
        if width == 0 and height == 0 and (color == 'red' or
                                           emphasis is None):
            raise ValueError("I don't think so -- values are %s, %s" %
                             (width, height))
        Blob.__init__(self, width, height,
                      color, emphasis, highlight)

Пустые строки

Отделяйте функции верхнего уровня и определения классов двумя пустыми строками.

Определения методов внутри класса разделяются одной пустой строкой.

Дополнительные пустые строки возможно использовать для разделения различных групп похожих функций. Пустые строки могут быть опущены между несколькими связанными однострочниками (например, набор фиктивных реализаций).

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

Python расценивает символ control+L как незначащий (whitespace), и вы можете использовать его, потому что многие редакторы обрабатывают его как разрыв страницы — таким образом логические части в файле будут на разных страницах. Однако, не все редакторы распознают control+L и могут на его месте отображать другой символ.

Кодировка исходного файла

Кодировка Python должна быть UTF-8 (ASCII в Python 2).

Файлы в ASCII (Python 2) или UTF-8 (Python 3) не должны иметь объявления кодировки.

В стандартной библиотеке, нестандартные кодировки должны использоваться только для целей тестирования, либо когда комментарий или строка документации требует упомянуть имя автора, содержащего не ASCII символы; в остальных случаях использование \x, \u, \U или \N — наиболее предпочтительный способ включить не ASCII символы в строковых литералах.

Начиная с версии python 3.0 в стандартной библиотеке действует следующее соглашение: все идентификаторы обязаны содержать только ASCII символы, и означать английские слова везде, где это возможно (во многих случаях используются сокращения или неанглийские технические термины). Кроме того, строки и комментарии тоже должны содержать лишь ASCII символы. Исключения составляют: (а) test case, тестирующий не-ASCII особенности программы, и (б) имена авторов. Авторы, чьи имена основаны не на латинском алфавите, должны транслитерировать свои имена в латиницу.

Проектам с открытым кодом для широкой аудитории также рекомендуется использовать это соглашение.

Импорты

Каждый импорт, как правило, должен быть на отдельной строке.

Правильно:
```
import os
import sys
```
Неправильно:
```
import sys, os
```
В то же время, можно писать так:
```
from subprocess import Popen, PIPE
```
Импорты всегда помещаются в начале файла, сразу после комментариев к модулю и строк документации, и перед объявлением констант.

Импорты должны быть сгруппированы в следующем порядке:
1. импорты из стандартной библиотеки
2. импорты сторонних библиотек
3. импорты модулей текущего проекта
Вставляйте пустую строку между каждой группой импортов.

Указывайте спецификации __all__ после импортов.
Рекомендуется абсолютное импортирование, так как оно обычно более читаемо и ведет себя лучше (или, по крайней мере, даёт понятные сообщения об ошибках) если импортируемая система настроена неправильно (например, когда каталог внутри пакета заканчивается на sys.path):
```
import mypkg.sibling
from mypkg import sibling
from mypkg.sibling import example
```
Тем не менее, явный относительный импорт является приемлемой альтернативой абсолютному импорту, особенно при работе со сложными пакетами, где использование абсолютного импорта было бы излишне подробным:
```
from . import sibling
from .sibling import example
```
В стандартной библиотеке следует избегать сложной структуры пакетов и всегда использовать абсолютные импорты.

Неявные относительно импорты никогда не должны быть использованы, и были удалены в Python 3.
Когда вы импортируете класс из модуля, вполне можно писать вот так:
```
from myclass import MyClass
from foo.bar.yourclass import YourClass
```
Если такое написание вызывает конфликт имен, тогда пишите:
```
import myclass
import foo.bar.yourclass
```
И используйте «myclass.MyClass» и «foo.bar.yourclass.YourClass».
Шаблоны импортов (from import *) следует избегать, так как они делают неясным то, какие имена присутствуют в глобальном пространстве имён, что вводит в заблуждение как читателей, так и многие автоматизированные средства. Существует один оправданный пример использования шаблона импорта, который заключается в опубликовании внутреннего интерфейса как часть общественного API (например, переписав реализацию на чистом Python в модуле акселератора (и не будет заранее известно, какие именно функции будут перезаписаны).

Пробелы в выражениях и инструкциях

Избегайте использования пробелов в следующих ситуациях:

Непосредственно внутри круглых, квадратных или фигурных скобок.

Правильно:
```
spam(ham[1], {eggs: 2})
```
Неправильно:
```
spam( ham[ 1 ], { eggs: 2 } )
```
Непосредственно перед запятой, точкой с запятой или двоеточием:

Правильно:
```
if x == 4: print(x, y); x, y = y, x
```
Неправильно:
```
if x == 4 : print(x , y) ; x , y = y , x
```
Сразу перед открывающей скобкой, после которой начинается список аргументов при вызове функции:

Правильно:
```
spam(1)
```
Неправильно:
```
spam (1)
```
Сразу перед открывающей скобкой, после которой следует индекс или срез:

Правильно:
```
dict['key'] = list[index]
```
Неправильно:
```
dict ['key'] = list [index]
```
Использование более одного пробела вокруг оператора присваивания (или любого другого) для того, чтобы выровнять его с другим:

Правильно:
```
x = 1
y = 2
long_variable = 3
```
Неправильно:
```
x             = 1
y             = 2
long_variable = 3
```

Другие рекомендации

Всегда окружайте эти бинарные операторы одним пробелом с каждой стороны: присваивания (=, +=, -= и другие), сравнения (==, <, >, !=, <>, <=, >=, in, not in, is, is not), логические (and, or, not).
Если используются операторы с разными приоритетами, попробуйте добавить пробелы вокруг операторов с самым низким приоритетом. Используйте свои собственные суждения, однако, никогда не используйте более одного пробела, и всегда используйте одинаковое количество пробелов по обе стороны бинарного оператора.

Правильно:
```
i = i + 1
submitted += 1
x = x*2 - 1
hypot2 = x*x + y*y
c = (a+b) * (a-b)
```
Неправильно:
```
i=i+1
submitted +=1
x = x * 2 - 1
hypot2 = x * x + y * y
c = (a + b) * (a - b)
```
Не используйте пробелы вокруг знака =, если он используется для обозначения именованного аргумента или значения параметров по умолчанию.

Правильно:
```
def complex(real, imag=0.0):
    return magic(r=real, i=imag)
```
Неправильно:
```
def complex(real, imag = 0.0):
    return magic(r = real, i = imag)
```
Не используйте составные инструкции (несколько команд в одной строке).

Правильно:
```
if foo == 'blah':
    do_blah_thing()
do_one()
do_two()
do_three()
```
Неправильно:
```
if foo == 'blah': do_blah_thing()
do_one(); do_two(); do_three()
```

Иногда можно писать тело циклов while, for или ветку if в той же строке, если команда короткая, но если команд несколько, никогда так не пишите. А также избегайте длинных строк!

Точно неправильно:

if foo == 'blah': do_blah_thing()
for x in lst: total += x
while t < 10: t = delay()

Вероятно, неправильно:

if foo == 'blah': do_blah_thing()
else: do_non_blah_thing()

try: something()
finally: cleanup()

do_one(); do_two(); do_three(long, argument,
                             list, like, this)

if foo == 'blah': one(); two(); three()

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

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

Ставьте два пробела после точки в конце предложения.

Программисты, которые не говорят на английском языке, пожалуйста, пишите комментарии на английском, если только вы не уверены на 120%, что ваш код никогда не будут читать люди, не знающие вашего родного языка.

Блоки комментариев

Блок комментариев обычно объясняет код (весь, или только некоторую часть), идущий после блока, и должен иметь тот же отступ, что и сам код. Каждая строчка такого блока должна начинаться с символа # и одного пробела после него (если только сам текст комментария не имеет отступа).

Абзацы внутри блока комментариев разделяются строкой, состоящей из одного символа #.

«Встрочные» комментарии

Старайтесь реже использовать подобные комментарии.

Такой комментарий находится в той же строке, что и инструкция. «Встрочные» комментарии должны отделяться по крайней мере двумя пробелами от инструкции. Они должны начинаться с символа # и одного пробела.

Комментарии в строке с кодом не нужны и только отвлекают от чтения, если они объясняют очевидное. Не пишите вот так:

x = x + 1                 # Increment x

Впрочем, такие комментарии иногда полезны:

x = x + 1                 # Компенсация границы

Строки документации

Пишите документацию для всех публичных модулей, функций, классов, методов. Строки документации необязательны для приватных методов, но лучше написать, что делает метод. Комментарий нужно писать после строки с def.
PEP 257 объясняет, как правильно и хорошо документировать. Заметьте, очень важно, чтобы закрывающие кавычки стояли на отдельной строке. А еще лучше, если перед ними будет ещё и пустая строка, например:
```
"""Return a foobang

Optional plotz says to frobnicate the bizbaz first.

"""
```
Для однострочной документации можно оставить закрывающие кавычки на той же строке.

Контроль версий

Если вам нужно использовать Subversion, CVS или RCS в ваших исходных кодах, делайте вот так:

__version__ = "$Revision: 1a40d4eaa00b $"
# $Source$

Вставляйте эти строки после документации модуля перед любым другим кодом и отделяйте их пустыми строками по одной до и после.

Соглашения по именованию

Соглашения по именованию переменных в python немного туманны, поэтому их список никогда не будет полным — тем не менее, ниже мы приводим список рекомендаций, действующих на данный момент. Новые модули и пакеты должны быть написаны согласно этим стандартам, но если в какой-либо уже существующей библиотеке эти правила нарушаются, предпочтительнее писать в едином с ней стиле.

Главный принцип

Имена, которые видны пользователю как часть общественного API должны следовать конвенциям, которые отражают использование, а не реализацию.

Описание: Стили имен

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

Обычно различают следующие стили:

b (одиночная маленькая буква)
B (одиночная заглавная буква)
lowercase (слово в нижнем регистре)
lower_case_with_underscores (слова из маленьких букв с подчеркиваниями)
UPPERCASE (заглавные буквы)
UPPERCASE_WITH_UNDERSCORES (слова из заглавных букв с подчеркиваниями)
CapitalizedWords (слова с заглавными буквами, или CapWords, или CamelCase). Замечание: когда вы используете аббревиатуры в таком стиле, пишите все буквы аббревиатуры заглавными — HTTPServerError лучше, чем HttpServerError.
mixedCase (отличается от CapitalizedWords тем, что первое слово начинается с маленькой буквы)
Capitalized_Words_With_Underscores (слова с заглавными буквами и подчеркиваниями — уродливо!)

Ещё существует стиль, в котором имена, принадлежащие одной логической группе, имеют один короткий префикс. Этот стиль редко используется в python, но мы упоминаем его для полноты. Например, функция os.stat() возвращает кортеж, имена в котором традиционно имеют вид st_mode, st_size, st_mtime и так далее. (Так сделано, чтобы подчеркнуть соответствие этих полей структуре системных вызовов POSIX, что помогает знакомым с ней программистам).

В библиотеке X11 используется префикс Х для всех public-функций. В python этот стиль считается излишним, потому что перед полями и именами методов стоит имя объекта, а перед именами функций стоит имя модуля.

В дополнение к этому, используются следующие специальные формы записи имен с добавлением символа подчеркивания в начало или конец имени:

_single_leading_underscore: слабый индикатор того, что имя используется для внутренних нужд. Например, from M import * не будет импортировать объекты, чьи имена начинаются с символа подчеркивания.
single_trailing_underscore_: используется по соглашению для избежания конфликтов с ключевыми словами языка python, например:
```
Tkinter.Toplevel(master, class_='ClassName')
```
__double_leading_underscore: изменяет имя атрибута класса, то есть в классе FooBar поле __boo становится _FooBar__boo.
__double_leading_and_trailing_underscore__ (двойное подчеркивание в начале и в конце имени): магические методы или атрибуты, которые находятся в пространствах имен, управляемых пользователем. Например, __init__, __import__ или __file__. Не изобретайте такие имена, используйте их только так, как написано в документации.

Предписания: соглашения по именованию

Имена, которых следует избегать

Никогда не используйте символы l (маленькая латинская буква «эль»), O (заглавная латинская буква «о») или I (заглавная латинская буква «ай») как однобуквенные идентификаторы.

В некоторых шрифтах эти символы неотличимы от цифры один и нуля. Если очень нужно l, пишите вместо неё заглавную L.

Имена модулей и пакетов

Модули должны иметь короткие имена, состоящие из маленьких букв. Можно использовать символы подчеркивания, если это улучшает читабельность. То же самое относится и к именам пакетов, однако в именах пакетов не рекомендуется использовать символ подчёркивания.

Так как имена модулей отображаются в имена файлов, а некоторые файловые системы являются нечувствительными к регистру символов и обрезают длинные имена, очень важно использовать достаточно короткие имена модулей — это не проблема в Unix, но, возможно, код окажется непереносимым в старые версии Windows, Mac, или DOS.

Когда модуль расширения, написанный на С или C++, имеет сопутствующий python-модуль (содержащий интерфейс высокого уровня), С/С++ модуль начинается с символа подчеркивания, например, _socket.

Имена классов

Имена классов должны обычно следовать соглашению CapWords.

Вместо этого могут использоваться соглашения для именования функций, если интерфейс документирован и используется в основном как функции.

Обратите внимание, что существуют отдельные соглашения о встроенных именах: большинство встроенных имен — одно слово (либо два слитно написанных слова), а соглашение CapWords используется только для именования исключений и встроенных констант.

Имена исключений

Так как исключения являются классами, к исключениями применяется стиль именования классов. Однако вы можете добавить Error в конце имени (если, конечно, исключение действительно является ошибкой).

Имена глобальных переменных

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

Добавляйте в модули, которые написаны так, чтобы их использовали с помощью from M import *, механизм __all__, чтобы предотвратить экспортирование глобальных переменных. Или же, используйте старое соглашение, добавляя перед именами таких глобальных переменных один символ подчеркивания (которым вы можете обозначить те глобальные переменные, которые используются только внутри модуля).

Имена функций

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

Стиль mixedCase допускается в тех местах, где уже преобладает такой стиль, для сохранения обратной совместимости.

Аргументы функций и методов

Всегда используйте self в качестве первого аргумента метода экземпляра объекта.

Всегда используйте cls в качестве первого аргумента метода класса.

Если имя аргумента конфликтует с зарезервированным ключевым словом python, обычно лучше добавить в конец имени символ подчеркивания, чем исказить написание слова или использовать аббревиатуру. Таким образом, class_ лучше, чем clss. (Возможно, хорошим вариантом будет подобрать синоним).

Имена методов и переменных экземпляров классов

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

Используйте один символ подчёркивания перед именем для непубличных методов и атрибутов.

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

Python искажает эти имена: если класс Foo имеет атрибут с именем __a, он не может быть доступен как Foo.__a. (Настойчивый пользователь все еще может получить доступ, вызвав Foo._Foo__a.) Вообще, два ведущих подчеркивания должны использоваться только для того, чтобы избежать конфликтов имен с атрибутами классов, предназначенных для наследования.

Примечание: есть некоторые разногласия по поводу использования __ имена (см. ниже).

Константы

Константы обычно объявляются на уровне модуля и записываются только заглавными буквами, а слова разделяются символами подчеркивания. Например: MAX_OVERFLOW, TOTAL.

Проектирование наследования

Обязательно решите, каким должен быть метод класса или экземпляра класса (далее — атрибут) — публичный или непубличный. Если вы сомневаетесь, выберите непубличный атрибут. Потом будет проще сделать его публичным, чем наоборот.

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

Мы не используем термин «приватный атрибут», потому что на самом деле в python таких не бывает.

Другой тип атрибутов классов принадлежит так называемому API подклассов (в других языках они часто называются protected). Некоторые классы проектируются так, чтобы от них наследовали другие классы, которые расширяют или модифицируют поведение базового класса. Когда вы проектируете такой класс, решите и явно укажите, какие атрибуты являются публичными, какие принадлежат API подклассов, а какие используются только базовым классом.

Теперь сформулируем рекомендации:

Открытые атрибуты не должны иметь в начале имени символа подчеркивания.
Если имя открытого атрибута конфликтует с ключевым словом языка, добавьте в конец имени один символ подчеркивания. Это более предпочтительно, чем аббревиатура или искажение написания (однако, у этого правила есть исключение — аргумента, который означает класс, и особенно первый аргумент метода класса (class method) должен иметь имя cls).
Назовите простые публичные атрибуты понятными именами и не пишите сложные методы доступа и изменения (accessor/mutator, get/set, — прим. перев.) Помните, что в python очень легко добавить их потом, если потребуется. В этом случае используйте свойства (properties), чтобы скрыть функциональную реализацию за синтаксисом доступа к атрибутам.

Примечание 1: Свойства (properties) работают только в классах нового стиля (в Python 3 все классы являются таковыми).

Примечание 2: Постарайтесь избавиться от побочных эффектов, связанным с функциональным поведением; впрочем, такие вещи, как кэширование, вполне допустимы.

Примечание 3: Избегайте использования вычислительно затратных операций, потому что из-за записи с помощью атрибутов создается впечатление, что доступ происходит (относительно) быстро.
Если вы планируете класс таким образом, чтобы от него наследовались другие классы, но не хотите, чтобы подклассы унаследовали некоторые атрибуты, добавьте в имена два символа подчеркивания в начало, и ни одного — в конец. Механизм изменения имен в python сработает так, что имя класса добавится к имени такого атрибута, что позволит избежать конфликта имен с атрибутами подклассов.

Примечание 1: Будьте внимательны: если подкласс будет иметь то же имя класса и имя атрибута, то вновь возникнет конфликт имен.

Примечание 2: Механизм изменения имен может затруднить отладку или работу с __getattr__(), однако он хорошо документирован и легко реализуется вручную.

Примечание 3: Не всем нравится этот механизм, поэтому старайтесь достичь компромисса между необходимостью избежать конфликта имен и возможностью доступа к этим атрибутам.

Общие рекомендации

Код должен быть написан так, чтобы не зависеть от разных реализаций языка (PyPy, Jython, IronPython, Pyrex, Psyco и пр.).

Например, не полагайтесь на эффективную реализацию в CPython конкатенации строк в выражениях типа a+=b или a=a+b. Такие инструкции выполняются значительно медленнее в Jython. В критичных к времени выполнения частях программы используйте ».join() — таким образом склеивание строк будет выполнено за линейное время независимо от реализации python.

Сравнения с None должны обязательно выполняться с использованием операторов is или is not, а не с помощью операторов сравнения. Кроме того, не пишите if x, если имеете в виду if x is not None — если, к примеру, при тестировании такая переменная может принять значение другого типа, отличного от None, но при приведении типов может получиться False!

При реализации методов сравнения, лучше всего реализовать все 6 операций сравнения (__eq__, __ne__, __lt__, __le__, __gt__, __ge__), чем полагаться на то, что другие программисты будут использовать только конкретный вид сравнения.

Для минимизации усилий можно воспользоваться декоратором functools.total_ordering() для реализации недостающих методов.

PEP 207 указывает, что интерпретатор может поменять y > х на х < y, y >= х на х <= y, и может поменять местами аргументы х == y и х != y. Гарантируется, что операции sort() и min() используют оператор <, а max() использует оператор >. Однако, лучше всего осуществить все шесть операций, чтобы не возникало путаницы в других местах.

Всегда используйте выражение def, а не присваивание лямбда-выражения к имени.

Правильно:

def f(x): return 2*x

Неправильно:

f = lambda x: 2*x

Наследуйте свой класс исключения от Exception, а не от BaseException. Прямое наследование от BaseException зарезервировано для исключений, которые не следует перехватывать.

Используйте цепочки исключений соответствующим образом. В Python 3, «raise X from Y» следует использовать для указания явной замены без потери отладочной информации.

Когда намеренно заменяется исключение (использование «raise X» в Python 2 или «raise X from None» в Python 3.3+), проследите, чтобы соответствующая информация передалась в новое исключение (такие, как сохранение имени атрибута при преобразовании KeyError в AttributeError или вложение текста исходного исключения в новом).

Когда вы генерируете исключение, пишите raise ValueError(‘message’) вместо старого синтаксиса raise ValueError, message.

Старая форма записи запрещена в python 3.

Такое использование предпочтительнее, потому что из-за скобок не нужно использовать символы для продолжения перенесенных строк, если эти строки длинные или если используется форматирование.

Когда код перехватывает исключения, перехватывайте конкретные ошибки вместо простого выражения except:.

К примеру, пишите вот так:

try:
    import platform_specific_module
except ImportError:
    platform_specific_module = None

Простое написание «except:» также перехватит и SystemExit, и KeyboardInterrupt, что породит проблемы, например, сложнее будет завершить программу нажатием control+C. Если вы действительно собираетесь перехватить все исключения, пишите «except Exception:».

Хорошим правилом является ограничение использования «except:», кроме двух случаев:

Если обработчик выводит пользователю всё о случившейся ошибке; по крайней мере, пользователь будет знать, что произошла ошибка.
Если нужно выполнить некоторый код после перехвата исключения, а потом вновь «бросить» его для обработки где-то в другом месте. Обычно же лучше пользоваться конструкцией «try…finally».

При связывании перехваченных исключений с именем, предпочитайте явный синтаксис привязки, добавленный в Python 2.6:

try:
    process_data()
except Exception as exc:
    raise DataProcessingFailedError(str(exc))

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

При перехвате ошибок операционной системы, предпочитайте использовать явную иерархию исключений, введенную в Python 3.3, вместо анализа значений errno.

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

Правильно:

try:
    value = collection[key]
except KeyError:
    return key_not_found(key)
else:
    return handle_value(value)

Неправильно:

try:
    # Здесь много действий!
    return handle_value(collection[key])
except KeyError:
    # Здесь также перехватится KeyError, который может быть сгенерирован handle_value()
    return key_not_found(key)

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

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

Правильно:

with conn.begin_transaction():
    do_stuff_in_transaction(conn)

Неправильно:

with conn:
    do_stuff_in_transaction(conn)

Последний пример не дает никакой информации, указывающей на то, что __enter__ и __exit__ делают что-то кроме закрытия соединения после транзакции. Быть явным важно в данном случае.

Используйте строковые методы вместо модуля string — они всегда быстрее и имеют тот же API для unicode-строк. Можно отказаться от этого правила, если необходима совместимость с версиями python младше 2.0.

В Python 3 остались только строковые методы.

Пользуйтесь ».startswith() и ».endswith() вместо обработки срезов строк для проверки суффиксов или префиксов.

startswith() и endswith() выглядят чище и порождают меньше ошибок. Например:

Правильно:

if foo.startswith('bar'):

Неправильно:

if foo[:3] == 'bar':

Сравнение типов объектов нужно делать с помощью isinstance(), а не прямым сравнением типов:

Правильно:

if isinstance(obj, int):

Неправильно:

if type(obj) is type(1):

Когда вы проверяете, является ли объект строкой, обратите внимание на то, что строка может быть unicode-строкой. В python 2 у str и unicode есть общий базовый класс, поэтому вы можете написать:

if isinstance(obj, basestring):

Отметим, что в Python 3, unicode и basestring больше не существуют (есть только str) и bytes больше не является своего рода строкой (это последовательность целых чисел).

Для последовательностей (строк, списков, кортежей) используйте тот факт, что пустая последовательность есть false:

Правильно:

if not seq:
if seq:

Неправильно:

if len(seq)
if not len(seq)

Не пользуйтесь строковыми константами, которые имеют важные пробелы в конце — они невидимы, а многие редакторы (а теперь и reindent.py) обрезают их.

Не сравнивайте логические типы с True и False с помощью ==:

Правильно:

if greeting:

Неправильно:

if greeting == True:

Совсем неправильно:

if greeting is True:

Оригинал

Специальные требования для оформления текстов для моих курсантов

В самом начале скрипта с кодом Python необходимо указывать следующие атрибуты:

#имя проекта: numpy-example
#номер версии: 1.0
#имя файла: example_2.py
#автор и его учебная группа: Е. Волков, ЭУ-142
#дата создания: 20.03.2019
#дата последней модификации: 25.03.2019
#связанные файлы: пакеты numpy, matplotlib
#описание: простейшие статистические вычисления
#версия Python: 3.6

Быстрый старт с IDLE Python

Вадим В. Костерин — Tue, 01 Oct 2019 01:37:30 +0000

Если вы недавно загрузили Python на свой компьютер, то, возможно, заметили новую программу под названием IDLE. Вы можете спросить: «Что эта программа делает на моем компьютере? Я её не загружал!». Возможно, вы осознанно не загружали эту программу, но IDLE есть в комплекте дистрибутива Python. IDLE поможет вам начать работу с языком прямо из коробки. Здесь вы узнаете, как работать в IDLE Python, несколько интересных приемов, которые можно использовать в своем путешествии с Python!

Что такое Python IDLE;
Как взаимодействовать с Python напрямую, используя IDLE;
Как редактировать, выполнять и отлаживать файлы Python с помощью IDLE;
Как настроить IDLE Python на свой вкус.

Содержание

Что есть IDLE Python?
- Интерактивный интерпретатор
- Редактор файлов
Как использовать оболочку Python IDLE
Как работать с файлами Python
Как улучшить рабочий процесс

Как отлаживать в IDLE
Как настроить Python IDLE
Заключение

Что есть IDLE Python?

Дистрибутив Python содержит Integrated Development and Learning Environment — Интегрированная среда разработки^એ и обучения, коротко IDLE или даже IDE. Это класс приложений, которые помогают более эффективно писать код. Хотя существует множество IDE, из которых можно что-то выбрать, Python IDLE очень проста, обычно, это идеальный инструмент для начинающего программиста.

Python IDLE входит в дистрибутив для Windows и Mac. Для Linux можно найти и загрузить Python IDLE с помощью вашего менеджера пакетов. После установки можно использовать Python IDLE в качестве интерактивного интерпретатора или редактора файлов.

Интерактивный интерпретатор

Лучшее место для экспериментов с кодом Python — это интерактивный интерпретатор, иначе известный как shell — оболочка. Оболочка — это базовая REPL^એ или Read-Eval-Print Loop. Она читает оператор Python, оценивает результат этого оператора и затем выводит результат на экран. Затем возвращается к следующему оператору.

Оболочка Python — отличное место для экспериментов с небольшими фрагментами кода. Доступ к ней можно получить через терминал или командную строку своего компьютера. Вы можете упростить свой рабочий процесс с Python IDLE, которая сразу же запустит Python при открытии.

Редактор файлов

Каждый программист должен иметь возможность редактировать и сохранять текстовые файлы. Программы Python — это файлы с расширением .py, которые содержат строчки кода. Python IDLE дает вам возможность легко создавать и редактировать такие файлы.

В Python IDLE есть несколько полезных функций, которые вы увидите в профессиональных IDE, такие как подсветка основного синтаксиса, автозавершение кода и авто-отступ. Профессиональные IDE — более надежное программное обеспечения, для которого крутая кривая обучения. Если вы только начинаете свой путь программирования, то Python IDLE — отличная альтернатива!

Как использовать оболочку Python IDLE

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

Интерактивный интерпретатор Python

Это пустое окно интерпретатора Python. Вы можете сразу начать «грузить» Python и проверить с помощью короткой строчки кода:

Исполнение кода в интерпретаторе

Здесь мы написали вызов функции print() для вывода на экран всего одной строчки "Hello, from IDLE!". Это самый простой способ взаимодействия с Python IDLE. Вы по-одиночке вводите команды, а Python каждый раз отвечает выводом результата на экран.

Далее посмотрите в главное меню и увидите Несколько вариантов использование оболочки:

Несколько вариантов использование оболочки

Вы можете перезапустить оболочку из этого меню. Если вы выберете этот пункт или одновременно нажмёте клавиши Ctrl + F6, то состояние оболочки очистится и она будет работать так, как будто вы запустили новый экземпляр Python IDLE. Оболочка забудет обо всем, что было раньше:

Перезапустим оболочку

На изображении выше вы сначала объявляете переменную, x = 5. Когда вы вызываете print(x), оболочка показывает правильный результат, число 5. Однако, когда вы перезапускаете оболочку и пытаетесь вызвать print(x), то печатается результат трассировки. Это сообщение об ошибке, в котором говорится, что переменная x не определена. Оболочка забыла обо всем, что было до этого.

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

Прерывание работы в оболочке

Сообщение об ошибке KeyboardInterrupt отображается красным цветом в нижней части окна. Программа получила прерывание и прекратила выполнение.

Как работать с файлами Python

Python IDLE имеет полноценный текстовый редактор файлов, который дает вам возможность писать и выполнять программы, не выходя из среды. Встроенный редактор имеет несколько встроенных функций, таких как завершение кода и авто‑отступы, которые ускоряют процесс кодирования. Для начала, давайте посмотрим, как писать и выполнять программы в Python IDLE.

Открытие файла

Для создания нового файла Python в главном меню выберите File → New File или Ctrl + N в Windows. В редакторе будет открыт пустой файл:

Создаём новый файл

Из этого окна вы можете записать новый файл Python. Можно открыть существующий файл, выбрав File → Open … в главном меню или Ctrl + O в Windows. Откроется менеджер файлов вашей операционной системы, где можно найти и выбрать нужный для работы файл.

Если вы заинтересованы в чтении исходного кода модуля Python, вы можете выбрать File → Path Browser. Это позволит просмотреть модули, которые видет Python IDLE. Если дважды щелкнуть на одном из них, то откроется редактор файлов и вы сможете его прочитать.

Содержимое этого окна будет таким же, как пути, возвращаемые при вызове sys.path. Если вам известно имя определенного модуля, который вы хотите просмотреть, вы можете выбрать File → Module Browser или Alt + C в Windows и записать имя модуля в появившемся окне.

Редактирование файла

Открыв файл в Python IDLE, можно внести в него изменения. Когда вы будете готовы отредактировать файл, то увидите что-то вроде этого:

Редактируем файл в Python IDLE

Содержимое вашего файла отображается в открытом окне. Панель в верхней части окна содержит три важных элемента:

Имя файла, который вы редактируете
Полный путь к папке, где вы можете найти этот файл на вашем компьютере
Версия Python, которую использует IDLE

На изображении выше вы редактируете файл myFile.py, который находится в папке Documents. Версия Python 3.7.1, которую вы можете увидеть в скобках.

В правом нижнем углу окна также есть две цифры:

Ln: показывает номер строки, на которой находится курсор.
Col. показывает номер столбца, на котором находится курсор.

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

В этом окне есть несколько визуальных подсказок, которые помогут вам не забыть сохранить свою работу. Если вы посмотрите внимательно, то увидите, что Python IDLE использует звездочки, чтобы сообщить вам, что в вашем файле есть несохраненные изменения:

Правки файла

Имя файла, отображаемое в верхней части окна IDLE, окружено звездочками. Это означает, что в вашем редакторе есть несохраненные изменения. Вы можете сохранить эти изменения с помощью стандартного сочетания клавиш в вашей системе или выбрать File → Save в строке меню. Убедитесь, что вы сохранили свой файл с расширением .py, чтобы подсветка синтаксиса была включена.

Выполнение файла

Если захотите выполнить файл, который создали в IDLE, то сначала надо убедиться, что он сохранен. Помните, что вы можете увидеть, правильно ли сохранен ваш файл, посмотрев звездочки вокруг имени файла в верхней части окна редактора файлов. Не беспокойся! Если забудешь, Python IDLE будет напоминать вам о необходимости сохранения всякий раз, когда вы пытаетесь выполнить несохраненный файл.

Чтобы выполнить файл в режиме IDLE, просто нажмите клавишу F5 на клавиатуре. Вы также можете выбрать Run → Run Module в строке меню. Любой из вариантов перезапустит интерпретатор Python, а затем запустит код, который вы написали, с новым интерпретатором. Процесс такой же, как когда вы запускаете python3 -i [имя файла] в своем терминале.

Когда ваш код будет выполнен, интерпретатор будет знать все о вашем коде, включая любые глобальные переменные, функции и классы. Это делает Python IDLE отличным местом для проверки ваших данных, если что-то пойдет не так. Если вам когда-либо понадобится прервать выполнение вашей программы, вы можете нажать Ctrl + C в интерпретаторе, который запускает ваш код.

Как улучшить рабочий процесс

Теперь, когда вы увидели, как писать, редактировать и выполнять файлы в Python IDLE, пришло время ускорить ваш рабочий процесс! Редактор Python IDLE предлагает несколько функций, которые вы увидите в большинстве профессиональных IDE для быстрого кодирования. Эти функции включают в себя авто⁵отступы, завершение кода и помощь в контексте кода.

Авто‑отступ

IDLE автоматически сделает отступ в коде, когда должен начаться новый блок. Обычно это происходит после ввода двоеточия (:). Когда вы нажимаете клавишу ввода после двоеточия, курсор автоматически перемещается на определенное количество пробелов и начинает новый блок кода.

Вы можете настроить, сколько пробелов будет перемещать курсор в настройках, но по умолчанию используются стандартные четыре пробела. Разработчики Python договорились о стандартном стиле для хорошо написанного кода Python, который включает в себя правила для отступов, пробелов и многое другое. Этот стандартный стиль был формализован и теперь известен как PEP 8. Чтобы узнать больше об этом, ознакомьтесь со статьёй Как оформить код.

Дополнение кода и подсказки

Когда вы пишете код для большого проекта или сложной проблемы, вы можете тратить много времени, просто набирая весь необходимый код. Завершение кода поможет вам сэкономить время, пытаясь завершить код за вас. Python IDLE имеет базовую функциональность завершения кода такую, как автозаполнение имен функций и классов. Для этого просто нажмите клавишу табуляции в редакторе после записи текста.

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

Подсказка и дополнение кода

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

Код в контексте

Код в контексте есть отличное свойство редактора файлов Python IDLE. Он покажет вам область действия функции, класса, цикла или иной другой конструкции. Это особенно полезно, когда вы просматриваете длинный файл и нужно отследить, где вы находитесь, просматривая код в редакторе.

Чтобы включить его, выберите Options → Code Context в главном меню. Вы увидите серую полосу в верхней части окна редактора:

Контекст кода включен

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

Как отлаживают в IDLE

Ошибка — всегда неожиданная проблема любой программы. Ошибки проявляются по разному, некоторые из них исправить труднее, чем другие. Ошибки достаточно хитры, иногда их нельзя обнаружить, просто прочитав свою код. К счастью, в Python IDLE есть несколько основных инструментов, которые помогут вам при отладке своих программ с легкостью!

Режим отладки интерпретатора

Если вы хотите запустить свой код с помощью встроенного отладчика,то вам нужно будет включить эту функцию. Для этого выберите < em>Debug → Debugger в строке меню Python IDLE. В интерпретаторе вы должны увидеть, что [DEBUG ON] появляется непосредственно перед приглашением (>>>), что означает, что интерпретатор готов и ждет.

Когда вы запустите ваш файл Python, появится окно отладчика:

DEBUG ON

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

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

Go: Следующяя точка останова^એ. Вы узнаете об этом в следующем разделе.
Шаг Нажмите, чтобы выполнить текущую строку и перейти к следующей.
Over: Если текущая строка кода содержит вызов функции, нажмите эту кнопку, чтобы войти в этк функцию. Другими словами, выполните эту функцию и перейдите к следующей строке, но не делайте паузу во время выполнения функции (если не существует точки останова).
Out: Если текущая строка кода находится в функции, нажмите эту кнопку, чтобы выйти их этой функции. Другими словами, продолжайте выполнение этой функции, пока не вернетесь к ней.

Будьте осторожны&nbps;— кнопки реверса нет! Во время отладки своей программы можно сделать шаг только вперед.

В окне отладки вы увидите четыре флажка:

Globals: глобальная информация о вашей программе
Locals: локальная информация о вашей программе во время выполнения
Steck: функции, которые выполняются во время выполнения
Source: ваш файл в редакторе IDLE

Выбрав один из них, вы увидите соответствующую информацию в окне отладки.

Breakpoints — точки останова

Точки останова^એ — это строка, которую вы определили как место, где интерпретатор должен приостановить выполнение кода. Она будет работать только при включенном режиме DEBUG, поэтому убедитесь, что вы сделали это в первую очередь.

Чтобы установить точку останова, щелкните правой кнопкой мыши строку кода, которую вы хотите приостановить. Строка кода будет выделена желтым цветом для визуализации. Вы можете установить столько точек останова в своем коде, сколько захотите. Чтобы отменить точку останова, снова щелкните правой кнопкой мыши по той же строке и выберите Clear Breakpoint.

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

Ошибки и исключения

Когда вы видите сообщение об ошибке в интерпретаторе, Python IDLE позволяет перейти прямо в файле непосредственно к строке, вызвавшей сбой. Все, что вам нужно сделать, это выделить номер строки или имя файла указанным курсором и выбрать Debug → Go to file/line в строке меню. Откроет файл на строке с ошибкой. Эта функция работает независимо от того, включен ли режим DEBUG.

Python IDLE также предоставляет инструмент под названием средство просмотра стека. Вы можете получить к нему доступ через параметр Debug в строке меню. Этот инструмент покажет вам трассировку ошибки, отображаемую в стеке последней ошибки или исключение, с которым столкнулся Python IDLE при запуске вашего кода. Когда происходит неожиданная или интересная ошибка, вам может быть полезно взглянуть на стек. В противном случае эту функцию может быть сложно разобрать, и, вероятно, она вам не пригодится, если вы не пишете очень сложный код.

How to Customize Python IDLE

Есть масса способов придать Python IDLE желаемый внешний вид. По умолчанию он основан на цветах в логотипе Python. Если это вам не нравится, то, почти всегда, ситуацию можно исправить на свой вкус.

Чтобы открыть окно настройки, выберите Options → Configure IDLE в строке меню. Чтобы просмотреть результат изменения, которое вы хотите внести, нажмите Apply. Когда вы закончите настройку Python IDLE, нажмите OK чтобы сохранить все ваши изменения. Если вы не хотите сохранять свои изменения, просто нажмите Cancel.

5 пользовательских настроек Python IDLE:

Fonts/Tabs — Шрифты/Закладки
Highlights — Подсветка кода
Keys — Клавиши
General — Общие
Extensions — Расширения

Let’s take a look at each of them now.

Fonts/Tabs

Первая вкладка позволяет изменять стиль, размер и цвет шрифта. Можно подобрать любой понравившийся вам стиль из вашей операционной системы. Окно настроек шрифта выглядит так:

Настройка Шрифты/Закладки

Вы можете использовать окно прокрутки, чтобы выбрать предпочитаемый шрифт. (Я рекомендую вам выбрать шрифт с фиксированной шириной, например Courier New.) Выберите размер шрифта, который будет достаточно большим, чтобы вам было хорошо видно. Вы также можете установить флажок рядом с Полужирным, чтобы переключить отображение всего текста полужирным шрифтом.

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

Highlights

Вторая вкладка настройки позволит изменить основные параметры Подсветки синтаксиса. Это важная функция любой IDE, которая помогает визуально различать различные конструкции Python и данные, используемые в вашем коде.

Python IDLE позволяет полностью настроить внешний вид вашего кода Python. Он предустановлен с тремя различными темами подсветки:

IDLE Day
IDLE Night
IDLE New

Вы можете выбрать одну из этих предустановленных тем или создать свою собственную тему прямо в этом окне:

Настройка Подсветки синтаксиса

К сожалению, IDLE не позволяет устанавливать пользовательские темы из файла. Вы должны создать таможенную тему из этого окна. Для этого вы можете просто начать менять цвета для разных предметов. Выберите элемент и нажмите Choose color for. Вы попадете в палитру цветов, где сможете выбрать именно тот цвет, который хотите использовать.

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

Keys

Третья вкладка настройки позволяет сопоставить различные нажатия клавиш с действиями, также известными как shortkey. Это жизненно важный компонент вашей производительности, когда вы используете IDE. Вы можете использовать свои собственные сочетания клавиш или те, которые встроены в IDLE. Предварительно установленные shortkey — хорошее место для начала:

Настройка клавиш быстрого доступа

Сочетания клавиш перечислены в алфавитном порядке по действию. Они перечислены в формате Action — Shortcut, где Action — это то, что произойдет, когда вы нажмете комбинацию клавиш в Shortcut. Если вы хотите использовать встроенный набор ключей, выберите сопоставление, соответствующее вашей операционной системе. Обратите особое внимание на различные клавиши и убедитесь, что они есть на вашей клавиатуре!

Creating Your Own Shortcuts

Настройка сочетаний клавиш очень похожа на настройку цветов подсветки синтаксиса. К сожалению, IDLE не позволяет устанавливать пользовательские сочетания клавиш из файла. Вы должны создать собственный набор ярлыков на вкладке Keys.

Выберите одну пару из списка и нажмите Get New Keys for Selection. Появится новое окно:

Создание пользовательских клавиш быстрого доступа

Здесь вы можете использовать флажки и меню прокрутки, чтобы выбрать комбинацию клавиш, которые вы хотите использовать. Вы можете выбрать Advanced Key Binding Entry >>, чтобы вручную ввести команду. Обратите внимание, что это не может забрать ключи, которые вы нажимаете. Вы должны буквально ввести команду, как вы видите, он отображается для вас в списке.

General

Четвертая вкладка окна настройки — это место для небольших общих изменений. Вкладка общих настроек выглядит следующим образом:

Общие настройки IDLE

Здесь вы можете настроить такие параметры, как размер окна и то, открывается ли оболочка или редактор файлов сначала при запуске Python IDLE. Большинство вещей в этом окне не так интересно менять, поэтому вам, вероятно, не нужно будет много возиться с ними.

Дополнения

Пятая вкладка окна настройки позволяет добавлять расширения в Python IDLE. Расширения позволяют добавлять новые, удивительные функции в Редактор и окно интерпретатора. Вы можете скачать их из интернета и установить их прямо в Python IDLE.

Чтобы посмотреть, какие расширения установлены, выберите Options → Configure IDLE → Extensions. В интернете есть масса расширений, о которых вы можете прочитать здесь, найти, которые вам нравятся и добавьте их в Python IDLE!

Заключение

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

Здесь раскрыты следующие темы:

Работа с оболочкой Python IDLE;
Использование Python IDLE в качестве редактора файлов;
Улучшение процесса разработки с помощью функций, которые помогут быстрее создавать код;
Отладка кода, просмотр ошибок и исключений;
Настройка Python IDLE по своему вкусу.

Теперь вы вооружены новым инструментом, который позволит вам продуктивно писать код Pythonic и сэкономит вам бесчисленные часы в будущем. Удачного программирования!

10 полезных библиотек Python

Вадим В. Костерин — Tue, 01 Oct 2019 01:55:49 +0000

Пакетов для Python создано уже очень много, поэтому ни один человек физически не может изучить их все. Только PyPi насчитывает 47 000 пакетов. В то время как pandas, scikit-learn или numpy у многих на слуху, про перечисленные здесь — уже достаточно старые, но всё ещё полезные — библиотеки часто забывают.

Delorean

Это – отличная библиотека для работы с датами и временем. Работа с временем с помощью неё в Python мне кажется наиболее естественной. Delorean чем-то похожа на Moment.js. Так же стоит отметить отличную документацию и бесчисленное количество отсылок к «Назад в будущее».

from delorean import Delorean
EST = "US/Eastern"
d = Delorean(timezone=EST)

Назад в будущее

Prettytable

Я почти уверен, что про эту библиотеку вы не слышали, ведь она выложена на GoogleCode, который в мире кодеров является точным аналогом Якутии.

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

from prettytable import PrettyTable
table = PrettyTable(["животное", "свирепость"])
table.add_row(["Оборотень", 100])
table.add_row(["Гризли", 87])
table.add_row(["Кролик из Кэрбенног", 110])
table.add_row(["Кот", -1])
table.add_row(["Утконос", 23])
table.add_row(["Дельфин", 63])
table.add_row(["Альбатрос", 44])
table.sort_key("свирепость")
table.reversesort = True
+----------------------+------------+
|       животное       | свирепость |
+----------------------+------------+
| Кролик из Кэрбенног |   110      |
|      Оборотень       |   100      |
|        Гризли        |    87      |
|       Дельфин        |    63      |
|       Альбатрос      |    44      |
|        Утконос       |    23      |
|         Кот          |    -1      |
+----------------------+------------+

Snowballstemmer

Ладно, признаюсь, первый раз я установил snowballstemmer из-за крутого названия. Но оказалось, что это действительно очень удобная маленькая библиотечка. Она содержит алгоритмы стемминга для 15 языков (включая русский).

from snowballstemmer import EnglishStemmer, SpanishStemmer
EnglishStemmer().stemWord("Gregory")
# Gregori
SpanishStemmer().stemWord("amarillo")
# amarill

Wget

Наверняка вам ни раз приходилось писать методы для какой-то специфической работы с вебом. Но я вас огорчу – вы делали это зря. Ведь уже есть wget. Рекурсивно скачать сайт? Забрать со страницы все изображения? Для wget это не проблема.

import wget
wget.download("http://www.cnn.com/")
# 100% [............................................................................] 280385 / 280385

PyMC

А эта библиотека предназначена для Байесовского анализа. По непонятным причинам эта библиотека используется гораздо реже, чем scikit-learn, а ведь очень зря.

from pymc.examples import disaster_model
from pymc import MCMC
M = MCMC(disaster_model)
M.sample(iter=10000, burn=1000, thin=10)
[-----------------100%-----------------] 10000 of 10000 complete in 1.4 sec

Sh

Я не могу себе позволить, чтобы вы ушли с этой страницы, не зная о sh. Как можно догадаться, sh импортирует в Python команды shell в виде функций. Это – суперудобная возможность, когда вы помните, как сделать что-то с помощью bash, но не помните, как это реализуется на Python (например, рекурсивный поиск по файлам).

from sh import find
find("/tmp")
/tmp/foo
/tmp/foo/file1.json
/tmp/foo/file2.json
/tmp/foo/file3.json
/tmp/foo/bar/file3.json

Fuzzywuzzy

Эта библиотека добавляет классных фич для сравнения данных. Может быть использована для связи записей в различных базах данных.

from fuzzywuzzy import fuzz
fuzz.ratio("Hit me with your best shot", "Hit me with your pet shark")
# 85

Progressbar

Да, да, эта библиотека делает именно то, о чём вы подумали – выводит прогрессбар.

from progressbar import ProgressBar
import time
pbar = ProgressBar(maxval=10)
for i in range(1, 11):
    pbar.update(i)
    time.sleep(1)
pbar.finish()
# 60% |########################################################                                      |

Colorama

Если уж вы занимаетесь добавление прогрессбаров в свои программы, то, может, стоит добавить ещё немного цвета? Справиться с этим вам поможет Colorama.

Сolorama

Uuid

Наверняка вам приходилось генерировать для пользователей ID, или рассылать покупателям промокоды, или делать ещё что-то, где нужно создать уникальные последовательности. UUID вам в этом поможет:

import uuid
print uuid.uuid4()
# e7bafa3d-274e-4b0a-b9cc-d898957b4b61

И если вы переживаете, что ID кончатся, то не стоит: их количество сравнимо с количеством атомов во вселенной.

Источник: blog.yhat.com

Нескучный NumPy

Вадим В. Костерин — Tue, 01 Oct 2019 02:29:31 +0000

Содержание

Что такое NumPy?
Создание массива
Доступ к элементам, срезы
Форма массива и ее изменение
Перестановка осей и транспонирование
Объединение массивов

Клонирование данных
Математические операции над элементами массива
Матричное умножение
Агрегаторы
Вместо заключения — пример

Что такое NumPy?

Это библиотека с открытым исходным кодом, некогда отделившаяся от проекта SciPy. NumPy является наследником Numeric и NumArray. Основан NumPy на библиотеке LAPAC, которая написана на Fortran. Не-python альтернативой для NumPy является Matlab.

В силу того, что NumPy базируется на Fortran это быстрая библиотека. А в силу того, что поддерживает векторные операции с многомерными массивами — крайне удобная.

Кроме базового варианта (многомерные массивы в базовом варианте) NumPy включает в себя набор пакетов для решения специализированных задач, например:

numpy.linalg — реализует операции линейной алгебры (простое умножение векторов и матриц есть в базовом варианте);
numpy.random — реализует функции для работы со случайными величинами;
numpy.fft — реализует прямое и обратное преобразование Фурье.

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

Но, прежде чем продолжить чтение этой статьи загрузите IDLE Python, где в режиме интерактивного интерпретатора повторяйте приведённые здесь скрипы и «в живую» смотрите на результат их выполнения. Но, не забудьте в начале сеанса записать:

import numpy

Создание массива

Создать массив можно несколькими способами:

преобразовать список в массив:

A = np.array([ [1, 2, 3], [4, 5, 6] ])
A
Out:
array([ [1, 2, 3],
       [4, 5, 6] ])

скопировать массив (копия и глубокая копия обязательна!!!):
```
B = A.copy()
B
Out:
array([ [1, 2, 3],
       [4, 5, 6] ])
```

создать нулевой или единичный массив заданного размера:

A = np.zeros((2, 3))
A
Out:
array([ [0., 0., 0.],
       [0., 0., 0.] ])
B = np.ones((3, 2))
B
Out:
array([ [1., 1.],
       [1., 1.],
       [1., 1.] ])

B = np.ones((3, 2))
B
Out:
array([ [1., 1.],
       [1., 1.],
       [1., 1.] ])

Либо взять размеры уже существующего массива:

A = np.array([ [1, 2, 3], [4, 5, 6] ])
B = np.zeros_like(A)
B
Out:
array([ [0, 0, 0],
       [0, 0, 0] ])

A = np.array([ [1, 2, 3], [4, 5, 6] ])
B = np.ones_like(A)
B
Out:
array([ [1, 1, 1],
       [1, 1, 1] ])

при создании двумерного квадратного массива можете сделать его единичной диагональной матрицей:
```
A = np.eye(3)
A
Out:
array([ [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.] ])
```
построить массив чисел от From (включая) до To (не включая) с шагом Step:
```
From = 2.5
To = 7
Step = 0.5
A = np.arange(From, To, Step)
A
Out:
array([2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5])
```
По умолчанию from = 0, step = 1, поэтому возможен вариант с одним параметром, интерпретируемым как To:
```
A = np.arange(5)
A
Out:
array([0, 1, 2, 3, 4])
```
Либо с двумя — как From и To:
```
A = np.arange(10, 15)
A
Out:
array([10, 11, 12, 13, 14])
```

Обратите внимание, что в методе №3 размеры массива передавались в качестве одного параметра (кортеж размеров). Вторым параметром в способах №3 и №4 можно указать желаемый тип элементов массива:

A = np.zeros((2, 3), 'int')
A
Out:
array([ [0, 0, 0],
       [0, 0, 0] ])

B = np.ones((3, 2), 'complex')
B
Out:
array([ [1.+0.j, 1.+0.j],
       [1.+0.j, 1.+0.j],
       [1.+0.j, 1.+0.j] ])

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

A = np.ones((3, 2))
B = A.astype('str')
B
Out:
array([ ['1.0', '1.0'],
       ['1.0', '1.0'],
       ['1.0', '1.0'] ], dtype='
Все доступные типы можно найти в словаре sctypes: 
np.sctypes
Out:
{'int': [numpy.int8, numpy.int16, numpy.int32, numpy.int64],
 'uint': [numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64],
 'float': [numpy.float16, numpy.float32, numpy.float64, numpy.float128],
 'complex': [numpy.complex64, numpy.complex128, numpy.complex256],
 'others': [bool, object, bytes, str, numpy.void]}

 <наверх>


Доступ к элементам, срезы
Доступ к элементам массива осуществляется по целочисленным индексами, начинается отсчет с 0:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A[1, 1]
Out:
5

Если представить многомерный массив как систему вложенных одномерных массивов (линейный массив, элементы которого могут быть линейными массивами), становится очевидной возможность получать доступ к подмассивам с использованием неполного набора индексов:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A[1]
Out:
array([4, 5, 6])

С учетом этой парадигмы, можем переписать пример доступа к одному элементу:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A[1][1]
Out:
5

При использовании неполного набора индексов, недостающие индексы неявно заменяются списком всех возможных индексов вдоль соответствующей оси. Сделать это явным образом можно, поставив «:«. Предыдущий пример с одним индексом можно переписать в следующем виде:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A[1, :]
Out:
array([4, 5, 6])

«Пропустить» индекс можно вдоль любой оси или осей, если за «пропущенной» осью последуют оси с индексацией, то «:» обязательно:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A[:, 1]
Out:
array([2, 5])

Индексы могут принимать отрицательные целые значения. В этом случае отсчет ведется от конца массива:
A = np.arange(5)
print(A)
A[-1]
Out:
[0 1 2 3 4]
4

Можно использовать не одиночные индексы, а списки индексов вдоль каждой оси:
A = np.arange(5)
print(A)
A[ [0, 1, -1] ]
Out:
[0 1 2 3 4]
array([0, 1, 4])

Либо диапазоны индексов в виде «From:To:Step». Такая конструкция называется срезом. Выбираются все элементы по списку индексов начиная с индекса From включительно, до индекса To не включая с шагом Step:
A = np.arange(5)
print(A)
A[0:4:2]
Out:
[0 1 2 3 4]
array([0, 2])

Шаг индекса имеет значение по умолчанию 1 и может быть пропущен:
A = np.arange(5)
print(A)
A[0:4]
Out:
[0 1 2 3 4]
array([0, 1, 2, 3])

Значения From и To тоже имеют дефолтные значения: 0 и размер массива по оси индексации соответственно:
A = np.arange(5)
print(A)
A[:4]
Out:
[0 1 2 3 4]
array([0, 1, 2, 3])

A = np.arange(5)
print(A)
A[-3:]
Out:
[0 1 2 3 4]
array([2, 3, 4])

Если вы хотите использовать From и To по умолчанию (все индексы по данной оси) а шаг отличный от 1, то вам необходимо использовать две пары двоеточий, чтобы интерпретатор смог идентифицировать единственный параметр как Step. Следующий код «разворачивает» массив вдоль второй оси, а вдоль первой не меняет:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
B = A[:, ::-1]
print("A", A)
print("B", B)
Out:
A [ [1 2 3]
 [4 5 6] ]
B [ [3 2 1]
 [6 5 4] ]

А теперь выполним
print(A)
B[0, 0] = 0
print(A)
Out:
[ [1 2 3]
 [4 5 6] ]
[ [1 2 0]
 [4 5 6] ]

Как видите, через B мы изменили данные в A. Вот почему в реальных задачах важно использовать копии. Пример выше должен был бы выглядеть так:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
B = A.copy()[:, ::-1]
print("A", A)
print("B", B)
Out:
A [ [1 2 3]
 [4 5 6] ]
B [ [3 2 1]
 [6 5 4] ]

В NumPy также реализована возможность доступа ко множеству элементов массива через булев индексный массив. Индексный массив должен совпадать по форме с индексируемым.
A = np.array([ [1, 2, 3], [4, 5, 6] ])
I = np.array([ [False, False, True], [ True, False, True] ])
A[I]
Out:
array([3, 4, 6])

Как видите, такая конструкция возвращает плоский массив, состоящий из элементов индексируемого массива, соответствующих истинным индексам. Однако, если мы используем такой доступ к элементам массива для изменения их значений, то форма массива сохранится:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
I = np.array([ [False, False, True], [ True, False, True] ])
A[I] = 0
print(A)
Out:
[ [1 2 0]
 [0 5 0] ]

Над индексирующими булевыми массивами определены логические операции logical_and, logical_or и logical_not выполняющие логические операции И, ИЛИ и НЕ поэлементно:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
I1 = np.array([ [False, False, True], [True, False, True] ])
I2 = np.array([ [False, True, False], [False, False, True] ])
B = A.copy()
C = A.copy()
D = A.copy()
B[np.logical_and(I1, I2)] = 0
C[np.logical_or(I1, I2)] = 0
D[np.logical_not(I1)] = 0
print('B\n', B)
print('\nC\n', C)
print('\nD\n', D)
Out:
B
 [ [1 2 3]
 [4 5 0] ]
C
 [ [1 0 0]
 [0 5 0] ]
D
 [ [0 0 3]
 [4 0 6] ]

logical_and и logical_or принимают 2 операнда, logical_not — один. Можно использовать операторы &, | и ~ для выполнения И, ИЛИ и НЕ соответственно с любым количеством операндов:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
I1 = np.array([ [False, False, True], [True, False, True] ])
I2 = np.array([ [False, True, False], [False, False, True] ])
A[I1 & (I1 | ~ I2)] = 0
print(A)
Out:
[ [1 2 0]
 [0 5 0] ]

Что эквивалентно применению только I1.
Получить индексирующий логический массив, соответствующий по форме массиву значений можно, записав логическое условие с именем массива в качестве операнда. Булево значение индекса будет рассчитано как истинность выражения для соответствующего элемента массива.
Найдем индексирующий массив I элементов, которые больше, чем 3, а элементы со значениями меньше чем 2 и больше 4 — обнулим:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
print('A before\n', A)
I = A > 3
print('I\n', I)
A[np.logical_or(A < 2, A > 4)] = 0
print('A after\n', A)
Out:
A before
 [ [1 2 3]
 [4 5 6] ]
I
 [ [False False False]
 [ True  True  True] ]
A after
 [ [0 2 3]
 [4 0 0] ]

 <наверх>


Форма массива и ее изменение
Многомерный массив можно представить как одномерный массив максимальной длины, нарезанный на фрагменты по длине самой последней оси и уложенный слоями по осям, начиная с последних.
Для наглядности рассмотрим пример:
A = np.arange(24)
B = A.reshape(4, 6)
C = A.reshape(4, 3, 2)
print('B\n', B)
print('\nC\n', C)
Out:
B
 [ [ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23] ]
C
 [ [ [ 0  1]
  [ 2  3]
  [ 4  5] ]
 [ [ 6  7]
  [ 8  9]
  [10 11] ]
 [ [12 13]
  [14 15]
  [16 17] ]
 [ [18 19]
  [20 21]
  [22 23] ] ]

В этом примере мы из одномерного массива длиной 24 элемента сформировали 2 новых массива. Массив B, размером 4 на 6. Если посмотреть на порядок значений, то видно, что вдоль второго измерения идут цепочки последовательных значений.
В массиве C, размером 4 на 3 на 2, непрерывные значения идут вдоль последней оси. Вдоль второй оси идут последовательно блоки, объединение которых дало бы в результате строки вдоль второй оси массива B.
А учитывая, что мы не делали копии, становится понятно, что это разные формы преставления одного и того же массива данных. Поэтому можно легко и быстро менять форму массива, не изменяя самих данных.
Чтобы узнать размерность массива (количество осей), можно использовать поле ndim (число), а чтобы узнать размер вдоль каждой оси — shape (кортеж). Размерность можно также узнать и по длине shape. Чтобы узнать полное количество элементов в массиве можно воспользоваться значением size:
A = np.arange(24)
C = A.reshape(4, 3, 2)
print(C.ndim, C.shape, len(C.shape), A.size)
Out:
3 (4, 3, 2) 3 24

Обратите внимание, что ndim и shape — это атрибуты, а не методы!

Чтобы увидеть массив одномерным, можно воспользоваться функцией ravel:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A.ravel()
Out:
array([1, 2, 3, 4, 5, 6])

Чтобы поменять размеры вдоль осей или размерность используется метод reshape:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A.reshape(3, 2)
Out:
array([ [1, 2],
       [3, 4],
       [5, 6] ])

Важно, чтобы количество элементов сохранилось. Иначе возникнет ошибка:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
A.reshape(3, 3)
Out:
ValueError                                Traceback (most recent call last)
 in 
      1 A = np.array([ [1, 2, 3], [4, 5, 6] ])
----> 2 A.reshape(3, 3)
ValueError: cannot reshape array of size 6 into shape (3,3)

Учитывая, что количество элементов постоянно, размер вдоль одной любой оси при выполнении reshape может быть вычислен из значений длины вдоль других осей. Размер вдоль одной оси можно обозначить -1 и тогда он будет вычислен автоматически:
A = np.arange(24)
B = A.reshape(4, -1)
C = A.reshape(4, -1, 2)
print(B.shape, C.shape)
Out:
(4, 6) (4, 3, 2)

Можно reshape использовать вместо ravel:
A = np.array([ [1, 2, 3], [4, 5, 6] ])
B = A.reshape(-1)
print(B.shape)
Out:
(6,)

Рассмотрим практическое применение некоторых возможностей для обработки изображений. В качестве объекта исследования будем использовать фотографию:

Исходная фотография для упражнений

Попробуем ее загрузить и визуализировать средствами Python. Для этого нам понадобятся OpenCV и Matplotlib (ext-1.py):
import cv2
from matplotlib import pyplot as plt

I = cv2.imread('susu-new-year.jpg')[:, :, ::-1]
flg = plt.figure(num=None, figsize=(15, 15), dpi=80, facecolor='w', edgecolor='k')
plt.imshow(I)
plt.show()

flg.savefig('./output-images/ext-1.jpg')

Результат будет такой:

Результат загрузки фото

Обратите внимание на строку загрузки: 
I = cv2.imread('susu-new-year.jpg')[:, :, ::-1]
print(I.shape)
Out:
(1280, 1920, 3)

OpenCV работает с изображениями в формате BGR, а нам привычен RGB. Мы меняем порядок байтов вдоль оси цвета без обращения к функциям OpenCV, используя конструкцию [:, :, ::-1].
Уменьшим изображение в 2 раза по каждой оси. Наше изображение имеет четные размеры по осям, соответственно, может быть уменьшено без интерполяции  (ext-2.py):
I_ = I.reshape(I.shape[0] // 2, 2, I.shape[1] // 2, 2, -1)
print(I_.shape)
plt.figure(num=None, figsize=(10, 10), dpi=80, facecolor='w', edgecolor='k')
plt.imshow(I_[:, 0, :, 0])
plt.show()

Уменьшим изображение в 2 раза по каждой оси
Поменяв форму массива, мы получили 2 новые оси, по 2 значения в каждой, им соответствуют кадры, составленные из нечетных и четных строк и столбцов исходного изображения. 
 <наверх>


Перестановка осей и транспонирование
В кроме изменения формы массива при неизменном порядке единиц данных, часто встречается необходимость изменить порядок следования осей, что естественным образом повлечет перестановки блоков данных.
Примером такого преобразования может быть транспонирование матрицы: взаимозамена строк и столбцов.
A = np.array([ [1, 2, 3], [4, 5, 6] ])
print('A\n', A)
print('\nA data\n', A.ravel())
B = A.T
print('\nB\n', B)
print('\nB data\n', B.ravel())
Out:
A
 [ [1 2 3]
 [4 5 6] ]
A data
 [1 2 3 4 5 6]
B
 [ [1 4]
 [2 5]
 [3 6] ]
B data
 [1 4 2 5 3 6]

В этом примере для транспонирования матрицы A использовалась конструкция A.T. Оператор транспонирования инвертирует порядок осей. Рассмотрим еще один пример с тремя осями:
C = np.arange(24).reshape(4, -1, 2)
print(C.shape, np.transpose(C).shape)
print()
print(C[0])
print()
print(C.T[:, :, 0])
Out:
[ [0 1]
 [2 3]
 [4 5] ]
[ [0 2 4]
 [1 3 5] ]

У этой короткой записи есть более длинный аналог: np.transpose(A). Это более универсальный инструмент для замены порядка осей. Вторым параметром можно задать кортеж номеров осей исходного массива, определяющий порядок их положения в результирующем массиве.
Для примера переставим первые две оси изображения. Картинка должна перевернуться, но цветовую ось оставим без изменения  (ext-3.py):
I_ = np.transpose(I, (1, 0, 2))
plt.figure(num=None, figsize=(15, 15), dpi=80, facecolor='w', edgecolor='k')
plt.imshow(I_)
plt.show()

Переставим первые две оси изображения
Для этого примера можно было применить другой инструмент swapaxes. Этот метод переставляет местами две оси, указанные в параметрах. Пример выше можно было реализовать так: 
I_ = np.swapaxes(I, 0, 1)

 <наверх>


Объединение массивов
Объединяемые массивы должны иметь одинаковое количество осей. Объединять массивы можно с образованием новой оси, либо вдоль уже существующей.
Для объединения с образованием новой оси исходные массивы должны иметь одинаковые размеры вдоль всех осей:
A = np.array([ [1, 2, 3, 4], [5, 6, 7, 8] ])
B = A[::-1]
C = A[:, ::-1]
D = np.stack((A, B, C))
print(D.shape)
D
Out:
(3, 2, 4)
array([ [ [1, 2, 3, 4],
        [5, 6, 7, 8] ],
       [ [5, 6, 7, 8],
        [1, 2, 3, 4] ],
       [ [4, 3, 2, 1],
        [8, 7, 6, 5] ] ])

Как видно из примера, массивы-операнды стали подмассивами нового объекта и выстроились вдоль новой оси, которая стоит самой первой по порядку.
Для объединения массивов вдоль существующей оси, они должны иметь одинаковый размер по всем осям, кроме выбранной для объединения, а по ней могут иметь произвольные размеры:
A = np.ones((2, 1, 2))
B = np.zeros((2, 3, 2))
C = np.concatenate((A, B), 1)
print(C.shape)
C
Out:
(2, 4, 2)
array([ [ [1., 1.],
        [0., 0.],
        [0., 0.],
        [0., 0.] ],
       [ [1., 1.],
        [0., 0.],
        [0., 0.],
        [0., 0.] ] ])

Для объединения по первой или второй оси можно использовать методы vstack и hstack соответственно. Покажем это на примере изображений. vstack объединяет изображения одинаковой ширины по высоте, а hsstack объединяет одинаковые по высоте картинки в одно широкое  (ext-4.py):
import numpy as np
import cv2
from matplotlib import pyplot as plt

I = cv2.imread('susu-new-year.jpg')[:, :, ::-1]
I_ = I.reshape(I.shape[0] // 2, 2, I.shape[1] // 2, 2, -1)
Ih = np.hstack((I_[:, 0, :, 0], I_[:, 0, :, 1]))
Iv = np.vstack((I_[:, 0, :, 0], I_[:, 1, :, 0]))
flg = plt.figure(num=None, figsize=(10, 10), dpi=80, facecolor='w', edgecolor='k')
plt.imshow(Ih)
plt.show()
flg.savefig('./output-images/ext-41.jpg')

flg = plt.figure(num=None, figsize=(10, 10), dpi=80, facecolor='w', edgecolor='k')
plt.imshow(Iv)
plt.show()
flg.savefig('./output-images/ext-42.jpg')

Объединение изображений по горизонтали
Объединение изображений по вертикали
Обратите внимание на то, что во всех примерах этого раздела объединяемые массивы передаются одним параметром (кортежем). Количество операндов может быть любым, а не обязательно только 2.
Также обратите внимание на то, что происходит с памятью, при объединении массивов:
A = np.array([ [1, 2, 3, 4], [5, 6, 7, 8] ])
B = A[::-1]
C = A[:, ::-1]
D = np.stack((A, B, C))
D[0, 0, 0] = 0
print(A)
Out:
[ [1 2 3 4]
 [5 6 7 8] ]

Так как создается новый объект, данные в него копируются из исходных массивов, поэтому изменения в новых данных не влияют на исходные.
 <наверх>


Клонирование данных
Оператор np.repeat(A, n) вернет одномерный массив с элементами массива A, каждый из которых будет повторен n раз.
A = np.array([ [1, 2, 3, 4], [5, 6, 7, 8] ])
print(np.repeat(A, 2))
Out:
[1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8]

После этого преобразования, можно перестроить геометрию массива и собрать повторяющиеся данные в одну ось:
A = np.array([ [1, 2, 3, 4], [5, 6, 7, 8] ])
B = np.repeat(A, 2).reshape(A.shape[0], A.shape[1], -1)
print(B)
Out:
[ [ [1 1]
  [2 2]
  [3 3]
  [4 4] ]
 [ [5 5]
  [6 6]
  [7 7]
  [8 8] ] ]

Этот вариант отличается от объединения массива с самим собой оператором stack только положением оси, вдоль которой стоят одинаковые данные. В примере выше это последняя ось, если использовать stack — первая:
A = np.array([ [1, 2, 3, 4], [5, 6, 7, 8] ])
B = np.stack((A, A))
print(B)
Out:
[ [ [1 2 3 4]
  [5 6 7 8] ]
 [ [1 2 3 4]
  [5 6 7 8] ] ]

Как бы ни было выполнено клонирование данных, следующим шагом можно переместить ось, вдоль которой стоят одинаковые значения, в любую позицию с системе осей:
A = np.array([ [1, 2, 3, 4], [5, 6, 7, 8] ])
B = np.transpose(np.stack((A, A)), (1, 0, 2))
C = np.transpose(np.repeat(A, 2).reshape(A.shape[0], A.shape[1], -1), (0, 2, 1))
print('B\n', B)
print('\nC\n', C)
Out:
B
 [ [ [1 2 3 4]
  [1 2 3 4] ]
 [ [5 6 7 8]
  [5 6 7 8] ]]
C
 [ [[1 2 3 4]
  [1 2 3 4] ]
 [ [5 6 7 8]
  [5 6 7 8] ] ]

Если же мы хотим «растянуть» какую либо ось, используя повторение элементов, то ось с одинаковыми значениями надо поставить после растягиваемой (используя transpose), а затем объединить эти две оси (используя reshape). Рассмотрим пример с растяжением изображения вдоль вертикальной оси за счет дублирования строк (ext-5.py):
import numpy as np
import cv2
from matplotlib import pyplot as plt

I0 = cv2.imread('susu-new-year.jpg')[:, :, ::-1]     # загрузили большое изображение
I1 = I0.reshape(I0.shape[0] // 2, 2, I0.shape[1] // 2, 2, -1)[:, 0, :, 0]  # уменьшили вдвое по каждому измерению
I2 = np.repeat(I1, 2)  # склонировали данные
I3 = I2.reshape(I1.shape[0], I1.shape[1], I1.shape[2], -1)
I4 = np.transpose(I3, (0, 3, 1, 2)) # поменяли порядок осей
I5 = I4.reshape(-1, I1.shape[1], I1.shape[2]) # объединили оси

print('I0', I0.shape)
print('I1', I1.shape)
print('I2', I2.shape)
print('I3', I3.shape)
print('I4', I4.shape)
print('I5', I5.shape)

flg = plt.figure(num=None, figsize=(10, 10), dpi=80, facecolor='w', edgecolor='k')
plt.imshow(I5)
plt.show()
flg.savefig('./output-images/ext-5.jpg')

Пример с растяжением изображения вдоль вертикальной оси за счет дублирования строк
 <наверх>


Математические операции над элементами массива
Если A и B массивы одинакового размера, то их можно складывать, умножать, вычитать, делить и возводить в степень. Эти операции выполняются поэлементно, результирующий массив будет совпадать по геометрии с исходными массивами, а каждый его элемент будет результатом выполнения соответствующей операции над парой элементов из исходных массивов:
A = np.array([ [-1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ])
B = np.array([ [1., -2., -3.], [7., 8., 9.], [4., 5., 6.], ])
C = A + B
D = A - B
E = A * B
F = A / B
G = A ** B
print('+\n', C, '\n')
print('-\n', D, '\n')
print('*\n', E, '\n')
print('/\n', F, '\n')
print('**\n', G, '\n')
Out:
+
 [ [ 0.  0.  0.]
 [11. 13. 15.]
 [11. 13. 15.] ] 
-
 [ [-2.  4.  6.]
 [-3. -3. -3.]
 [ 3.  3.  3.] ] 
*
 [ [-1. -4. -9.]
 [28. 40. 54.]
 [28. 40. 54.] ] 
/
 [ [-1.         -1.         -1.        ]
 [ 0.57142857  0.625       0.66666667]
 [ 1.75        1.6         1.5       ] ] 
**
 [ [-1.0000000e+00  2.5000000e-01  3.7037037e-02]
 [ 1.6384000e+04  3.9062500e+05  1.0077696e+07]
 [ 2.4010000e+03  3.2768000e+04  5.3144100e+05] ]

Можно выполнить любую операцию из приведенных выше над массивом и числом. В этом случае операция также выполнится над каждым из элементов массива:
A = np.array([ [-1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ])
B = -2.

C = A + B
D = A - B
E = A * B
F = A / B
G = A ** B
print('+\n', C, '\n')
print('-\n', D, '\n')
print('*\n', E, '\n')
print('/\n', F, '\n')
print('**\n', G, '\n')
Out:
+
 [ [-3.  0.  1.]
 [ 2.  3.  4.]
 [ 5.  6.  7.] ] 
-
 [ [ 1.  4.  5.]
 [ 6.  7.  8.]
 [ 9. 10. 11.] ] 
*
 [ [  2.  -4.  -6.]
 [ -8. -10. -12.]
 [-14. -16. -18.] ] 
/
 [ [ 0.5 -1.  -1.5]
 [-2.  -2.5 -3. ]
 [-3.5 -4.  -4.5] ] 
**
 [ [1.         0.25       0.11111111]
 [0.0625     0.04       0.02777778]
 [0.02040816 0.015625   0.01234568] ] 

Учитывая, что многомерный массив можно рассматривать как плоский массив (первая ось), элементы которого — массивы (остальные оси), возможно выполнение рассматриваемых операций над массивами A и B в случае, когда геометрия B совпадает с геометрией подмассивов A при фиксированном значении по первой оси. Иными словами, при совпадающем количестве осей и размерах A[i] и B. Этом случае каждый из массивов A[i] и B будут операндами для операций, определенных над массивами.
A = np.array([ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ])
B = np.array([-1.1, -1.2, -1.3])
C = A.T + B
D = A.T - B
E = A.T * B
F = A.T / B
G = A.T ** B
print('+\n', C, '\n')
print('-\n', D, '\n')
print('*\n', E, '\n')
print('/\n', F, '\n')
print('**\n', G, '\n')
Out:
+
 [ [-0.1  2.8  5.7]
 [ 0.9  3.8  6.7]
 [ 1.9  4.8  7.7] ] 
-
 [ [ 2.1  5.2  8.3]
 [ 3.1  6.2  9.3]
 [ 4.1  7.2 10.3] ] 
*
 [ [ -1.1  -4.8  -9.1]
 [ -2.2  -6.  -10.4]
 [ -3.3  -7.2 -11.7] ] 
/
 [ [-0.90909091 -3.33333333 -5.38461538]
 [-1.81818182 -4.16666667 -6.15384615]
 [-2.72727273 -5.         -6.92307692] ] 
**
 [ [1.         0.18946457 0.07968426]
 [0.4665165  0.14495593 0.06698584]
 [0.29865282 0.11647119 0.05747576] ] 

В этом примере массив B подвергается операции с каждой строкой массива A. При необходимости умножения/деления/сложения/вычитания/возведения степень подмассивов вдоль другой оси, необходимо использовать транспонирование, чтобы поставить нужную ось на место первой, а затем вернуть ее на свое место. Рассмотри пример выше, но с умножением на вектор B столбцов массива A:
A = np.array([ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ])
B = np.array([-1.1, -1.2, -1.3])
C = (A.T + B).T
D = (A.T - B).T
E = (A.T * B).T
F = (A.T / B).T
G = (A.T ** B).T
print('+\n', C, '\n')
print('-\n', D, '\n')
print('*\n', E, '\n')
print('/\n', F, '\n')
print('**\n', G, '\n')
Out:
+
 [ [-0.1  0.9  1.9]
 [ 2.8  3.8  4.8]
 [ 5.7  6.7  7.7] ] 
-
 [ [ 2.1  3.1  4.1]
 [ 5.2  6.2  7.2]
 [ 8.3  9.3 10.3] ] 
*
 [ [ -1.1  -2.2  -3.3]
 [ -4.8  -6.   -7.2]
 [ -9.1 -10.4 -11.7] ] 
/
 [ [-0.90909091 -1.81818182 -2.72727273]
 [-3.33333333 -4.16666667 -5.        ]
 [-5.38461538 -6.15384615 -6.92307692] ] 
**
 [ [1.         0.4665165  0.29865282]
 [0.18946457 0.14495593 0.11647119]
 [0.07968426 0.06698584 0.05747576] ] 

Для более сложных функций (например, для тригонометрических, экспоненты, логарифма, преобразования между градусами и радианами, модуля, корня квадратного и.д.) в NumPy есть реализация. Рассмотрим на примере экспоненты и логарифма:
A = np.array([ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.] ])
B = np.exp(A)
C = np.log(B)
print('A', A, '\n')
print('B', B, '\n')
print('C', C, '\n')
Out:
A [ [1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.] ] 
B [ [2.71828183e+00 7.38905610e+00 2.00855369e+01]
 [5.45981500e+01 1.48413159e+02 4.03428793e+02]
 [1.09663316e+03 2.98095799e+03 8.10308393e+03] ] 
C [ [1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.] ] 

С полным списком математических операций в NumPy можно ознакомиться тут.
 <наверх>


Матричное умножение
Описанная выше операция произведения массивов выполняется поэлементно. А при необходимости выполнения операций по правилам линейной алгебры над массивами как над тензорами можно воспользоваться методом dot(A, B). В зависимости от вида операндов, функция выполнит:

 если аргументы скаляры (числа), то выполнится умножение;
 если аргументы вектор (одномерный массив) и скаляр, то выполнится умножение массива на число;
 если аргументы вектора, то выполнится скалярное умножение (сумма поэлементных произведений);
 если аргументы тензор (многомерный массив) и скаляр, то выполнится умножение вектора на число;
 если аргументы тензора, то выполнится произведение тензоров по последней оси первого аргумента и предпоследней — второго;
 если аргументы матрицы, то выполнится произведение матриц (это частный случай произведения тензоров);
 если аргументы матрица и вектор, то выполнится произведение матрицы и вектора (это тоже частный случай произведения тензоров).

Для выполнения операций должны совпадать соответсвующие размеры: для векторов длины, для тензоров — длины вдоль осей, по которым будет происходить суммирование поэлементных произведений.
Рассмотрим примеры со скалярами и векторами:
# скаляры
A = 2
B = 3
print(np.dot(A, B), '\n')
# вектор и скаляр
A = np.array([2., 3., 4.])
B = 3
print(np.dot(A, B), '\n')
# вектора
A = np.array([2., 3., 4.])
B = np.array([-2., 1., -1.])
print(np.dot(A, B), '\n')
# тензор и скаляр
A = np.array([ [2., 3., 4.], [5., 6., 7.] ])
B = 2
print(np.dot(A, B), '\n')
Out:
6 
[ 6.  9. 12.] 
-5.0 
[ [ 4.  6.  8.]
 [10. 12. 14.] ] 

С тензорами посмотрим только на то, как меняется размер геометрия результирующего массива:
# матрица (тензор 2) и вектор (тензор 1)
A = np.ones((5, 6))
B = np.ones(6)
print('A:', A.shape, '\nB:', B.shape, '\nresult:', np.dot(A, B).shape, '\n\n')
# матрицы (тензора 2)
A = np.ones((5, 6))
B = np.ones((6, 7))
print('A:', A.shape, '\nB:', B.shape, '\nresult:', np.dot(A, B).shape, '\n\n')
# многомерные тензора
A = np.ones((5, 6, 7, 8))
B = np.ones((1, 2, 3, 8, 4))
print('A:', A.shape, '\nB:', B.shape, '\nresult:', np.dot(A, B).shape, '\n\n')
Out:
A: (5, 6) 
B: (6,) 
result: (5,) 
A: (5, 6) 
B: (6, 7) 
result: (5, 7) 
A: (5, 6, 7, 8) 
B: (1, 2, 3, 8, 4) 
result: (5, 6, 7, 1, 2, 3, 4) 

Для выполнения произведения тензоров с использованием других осей, вместо определенных для dot можно воспользоваться tensordot с явным указанием осей:
A = np.ones((1, 3, 7, 4))
B = np.ones((5, 7, 6, 7, 8))
print('A:', A.shape, '\nB:', B.shape, '\nresult:', np.tensordot(A, B, [2, 1]).shape, '\n\n')
Out:
A: (1, 3, 7, 4) 
B: (5, 7, 6, 7, 8) 
result: (1, 3, 4, 5, 6, 7, 8)  

Мы явно указали, используем третью ось первого массива и вторую — второго (размеры по этим осям должны совпадать).
 <наверх>


Агрегаторы
Агрегаторы — это методы NumPy позволяющие заменять данные интегральными характеристиками вдоль некоторых осей. Например, можно посчитать среднее значение, максимальное, минимальное, вариацию или еще какую-то характеристику вдоль какой-либо оси или осей и сформировать из этих данных новый массив. Форма нового массива будет содержать все оси исходного массива, кроме тех, вдоль которых подсчитывался агрегатор.
Для примера, сформируем массив со случайными значениями. Затем найдем минимальное, максимальное и среднее значение в его столбцах:
A = np.random.rand(4, 5)
print('A\n', A, '\n')
print('min\n', np.min(A, 0), '\n')
print('max\n', np.max(A, 0), '\n')
print('mean\n', np.mean(A, 0), '\n')
print('average\n', np.average(A, 0), '\n')
Out:
A
 [ [0.58481838 0.32381665 0.53849901 0.32401355 0.05442121]
 [0.34301843 0.38620863 0.52689694 0.93233065 0.73474868]
 [0.09888225 0.03710514 0.17910721 0.05245685 0.00962319]
 [0.74758173 0.73529492 0.58517879 0.11785686 0.81204847] ] 
min
 [0.09888225 0.03710514 0.17910721 0.05245685 0.00962319] 
max
 [0.74758173 0.73529492 0.58517879 0.93233065 0.81204847] 
mean
 [0.4435752  0.37060634 0.45742049 0.35666448 0.40271039] 
average
 [0.4435752  0.37060634 0.45742049 0.35666448 0.40271039]

При таком использовании mean и average выглядят синонимами. Но эти функции обладают разным набором дополнительных параметров. У нах разные возможности по маскированию и взвешиванию усредняемых данных.
Можно подсчитать интегральные характеристики и по нескольким осям:
A = np.ones((10, 4, 5))
print('sum\n', np.sum(A, (0, 2)), '\n')
print('min\n', np.min(A, (0, 2)), '\n')
print('max\n', np.max(A, (0, 2)), '\n')
print('mean\n', np.mean(A, (0, 2)), '\n')
Out:
sum
 [50. 50. 50. 50.] 
min
 [1. 1. 1. 1.] 
max
 [1. 1. 1. 1.] 
mean
 [1. 1. 1. 1.] 

В этом примере рассмотрена еще одна интегральная характеристика sum — сумма.
Список агрегаторов выглядит примерно так:

сумма: sum и nansum — вариант корректно обходящийся с nan;
произведение: prod и nanprod;
среднее и матожидание: average и mean (nanmean), nanaverage нету;
медиана: median и nanmedian;
перцентиль: percentile и nanpercentile;
вариация: var и nanvar;
стандартное отклонение (квадратный корень из вариации): std и nanstd;
минимальное значение:  min и nanmin;
максимальное значение: max и nanmax;
индекс элемента, имеющего минимальное значение: argmin и nanargmin;
индекс элемента, имеющего максимальное значение: argmax и nanargmax.

В случае использования argmin и argmax (соответственно, и nanargmin, и nanargmax) необходимо указывать одну ось, вдоль которой будет считаться характеристика.
Если не указать оси, то по умолчанию все рассматриваемые характеристики считаются по всему массиву. В этом случае argmin и argmax тоже корректно отработают и найдут индекс максимального или минимального элемента так, как буд-то все данные в массиве вытянуты вдоль одной оси командой ravel().
Еще следует отметить, агрегирующие методы определены не только как методы модуля NumPy, но и для самих массивов: запись np.aggregator(A, axes) эквивалентна записи A.aggregator(axes), где под aggregator подразумевается одна из рассмотренных выше функций, а под axes — индексы осей.
A = np.ones((10, 4, 5))
print('sum\n', A.sum((0, 2)), '\n')
print('min\n', A.min((0, 2)), '\n')
print('max\n', A.max((0, 2)), '\n')
print('mean\n', A.mean((0, 2)), '\n')
Out:
sum
 [50. 50. 50. 50.] 
min
 [1. 1. 1. 1.] 
max
 [1. 1. 1. 1.] 
mean
 [1. 1. 1. 1.] 

 <наверх>


Вместо заключения — пример
Давайте построим алгоритм линейной низкочастотной фильтрации изображения.
Для начала загрузим зашумленное изображение.
Рассмотрите это изображения, открыв в соседнем окне
Фильтровать изображение будем с использованием гауссова фильтра. Но вместо выполнения свертки непосредственно (с итерированием), применим взвешенное усреднение срезов изображения, сдвинутых относительно друг друга(ext-6.py):
def smooth(I):
    J = I.copy()

    J[1:-1] = (J[1:-1] // 2 + J[:-2] // 4 + J[2:] // 4)
    J[:, 1:-1] = (J[:, 1:-1] // 2 + J[:, :-2] // 4 + J[:, 2:] // 4)

    return J

Применим эту функцию к нашему изображению единожды, дважды и трижды:
I_noise = cv2.imread('susu-new-year-noise.jpg')

I_denoise_1 = smooth(I_noise)
I_denoise_2 = smooth(I_denoise_1)
I_denoise_3 = smooth(I_denoise_2)

cv2.imwrite('./output-images/susu-new-year-noise_1.jpg', I_denoise_1)
cv2.imwrite('./output-images/susu-new-year-noise_2.jpg', I_denoise_2)
cv2.imwrite('./output-images/susu-new-year-noise_3.jpg', I_denoise_3)

Получаем следующие результаты:

Делай раз


при однократном применении фильтра;
Делай два


при двукратном;
Делай три


при трехкратном.
Видно, что с повышением количества проходов фильтра снижается уровень шума. Но при этом снижается и четкость изображения. Это известная проблема линейных фильтров. Но наш метод денойзинга изображения не претендует на оптимальность: это лишь демонстрация возможностей NumPy реализации свертки без итераций.
Теперь давайте посмотрим, сверткам с какими ядрами эквивалентна наша фильтрация. Для этого подвергнем аналогичным преобразованиям одиночный единичный импульс и визуализируем. На самом деле импульс будет не единичным, а равным по амплитуде 255, так как само смешивание оптимизировано под целочисленные данные. Но это не мешает оценить общий вид ядер:
M = np.zeros((11, 11))

M[5, 5] = 255
M1 = smooth(M)
M2 = smooth(M1)
M3 = smooth(M2)

flg = plt.figure(num=None, figsize=(10, 10), dpi=80, facecolor='w', edgecolor='k')
plt.subplot(1, 3, 1)
plt.imshow(M1)

plt.subplot(1, 3, 2)
plt.imshow(M2)

plt.subplot(1, 3, 3)
plt.imshow(M3)

plt.show()
flg.savefig('./output-images/ext-7.jpg')


Мы рассмотрели далеко не полный набор возможностей NumPy, надеюсь, этого было достаточно для демонстрации всей мощи и красоты этого инструмента!
Скрипты этой статьи, посвященные работе с картинками расположены на Gihub
Основано на материалах Habr

PyGame — шпаргалка для использования

Вадим В. Костерин — Tue, 01 Oct 2019 12:11:49 +0000

Основные модули пакета Pygame

Модуль	Назначение
pygame.cdrom	Доступ к CD-приводам и управление ими
pygame.cursors	Загружает изображения курсора
pygame.display	Доступ к дисплею
pygame.draw	Рисует фигуры, линии и точки
pygame.event	Управление внешними событиями
pygame.font	Использует системные шрифты
pygame.image	Загружает и сохраняет изображение
pygame.joystick	Использует джойстики и аналогичные устройства
pygame.key	Считывает нажатия клавиш с клавиатуры
pygame.mixer	Загружает и воспроизводит мелодии
pygame.mouse	Управляет мышью
pygame.movie	Воспроизведение видеофайлов
pygame.music	Работает с музыкой и потоковым аудио
pygame.overlay	Доступ к расширенным видеоизображениям
pygame	Содержит функции Pygame высокого уровня
pygame.rect	Управляет прямоугольными областями
pygame.sndarray	Манипулирует звуковыми данными
pygame.sprite	Управление движущимися изображениями
pygame.surface	Управляет изображениями и экраном
pygame.surfarray	Манипулирует данными пикселей изображения
pygame.time	модуль pygame для управления временем и частотой кадров
pygame.transform	Изменение размера и перемещение изображений

Окно Pygame

# Подключение библиотеки PyGame
import pygame

# Инициализация PyGame
pygame.init()

# Окно игры: размер, позиция
gameScreen = pygame.display.set_mode((400, 300))

# Модуль os - позиция окна
import os
x = 100
y = 100
os.environ['Sp_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)

# Параметры окна
size = [500, 500]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Test drawings")
gameScreen.fill((0,0,255))
pygame.display.flip()

Цикл игры, выход из игры

# Цикл игры
runGame = True # флаг выхода из цикла игры
while runGame:
    # Отслеживание события: "закрыть окно"
    for event in pygame.event.get():
        if event.type == pygame.QUIT: runGame = False

# Выход из игры: 
pygame.quit()

Рисование базовых элементов
модуль pygame.draw

pygame.draw.rect	нарисовать прямоугольную форму
pygame.draw.polygon	фигуру с любым количеством сторон
pygame.draw.circle	круг вокруг точки
pygame.draw.ellipse	нарисовать круглую форму внутри прямоугольника
pygame.draw.arc	нарисовать секцию эллипса
pygame.draw.line	нарисовать сегмент прямой линии
pygame.draw.lines	для рисования нескольких смежных отрезков
pygame.draw.aaline	рисовать тонкую линию
pygame.draw.aalines	нарисовать связанную последовательность сглаженных линий

rect(Surface, color, Rect, wiph=0) -> Rect
polygon(Surface, color, pointlist, wiph=0) -> Rect
circle(Surface, color, pos, radius, wiph=0) -> Rect
ellipse(Surface, color, Rect, wiph=0) -> Rect
arc(Surface, color, Rect, start_angle, stop_angle, wiph=1) -> Rect
line(Surface, color, start_pos, end_pos, wiph=1) -> Rect
lines(Surface, color, closed, pointlist, wiph=1) -> Rect
aaline(Surface, color, startpos, endpos, blend=1) -> Rect
aalines(Surface, color, closed, pointlist, blend=1) -> Rect

Загрузка изображения

# Модуль pygame.image позволяет загрузить изображерие из файла и возвращает объект типа Surface.
pygame.image.load("путь к файлу" )

# загрузить новое изображение из файла
load(filename) -> Surface

# Загрузить изображение (путь к файлу для Windows)
myImage = pygame.image.load('images\\bg1.jpg')

# определить место размещения
myRect = (0,0,600,400)

# выгрузить объект Surface, который содержит загруженное из файла изображение (myImage), в описанное место на экране (myRect)
screen.blit(myImage,myRect)

Объект Rect

pygame.Rect

Pygame использует объекты Rect для хранения и манипулирования прямоугольными областями. Rect может быть создан из комбинации значений слева, сверху, ширины и высоты. Rect также могут быть созданы из объектов python, которые уже являются Rect или имеют атрибут с именем «rect».

Rect(left, top, wiph, height) -> Rect

Rect((left, top), (wiph, height)) -> Rect

Rect(object) -> Rect

Методы работы с Rect

pygame.Rect.copy	Возвращает новый прямоугольник, имеющий ту же позицию и размер, что и оригинал.
pygame.Rect.move	Возвращает новый прямоугольник, перемещаемый данным смещением. Аргументы x и y могут быть любым целочисленным значением, положительным или отрицательным.
pygame.Rect.move_ip	То же, что и метод Rect.move (), но работает на месте.
pygame.Rect.inflate	увеличивать или уменьшать размер прямоугольника, на месте
pygame.Rect.inflate_ip	увеличивать или уменьшать размер прямоугольника, на месте
pygame.Rect.clamp	перемещает прямоугольник внутри другого
pygame.Rect.clamp_ip	перемещает прямоугольник внутри другого, на месте
pygame.Rect.clip	обрезает прямоугольник внутри другого
pygame.Rect.union	соединяет два прямоугольника в один
pygame.Rect.union_ip	соединяет два прямоугольника в один, на месте
pygame.Rect.unionall	объединение многих прямоугольников
pygame.Rect.unionall_ip	объединение многих прямоугольников, на месте
pygame.Rect.fit	изменить размер и переместить прямоугольник учмиывая соотношение сторон
pygame.Rect.normalize	корректировать отрицательные размеры
pygame.Rect.contains	проверить, находится ли один прямоугольник внутри другого
pygame.Rect.collidepoint	проверить, находится ли точка внутри прямоугольника
pygame.Rect.colliderect	тест, пересекаются ли два прямоугольника
pygame.Rect.collidelist	проверить, пересекается ли хоть один прямоугольник в списке
pygame.Rect.collidelistall	пересекаются ли все прямоугольники в списке
pygame.Rect.collidedict	проверить, если один прямоугольник в словаре пересекается
pygame.Rect.collidedictall	пересекаются ли все прямоугольники в словаре

Обработка событий

Событие — это то, как Pygame сообщает о том, что что-то случилось за пределами кода программы. События создаются, например, при нажатии клавиш клавиатуры, мыши и размещаются в очереди, дожидаясь обработки.

Функция get в модуле pygame.event возвращает последнее событие, ожидающее в очереди и удаляет его из очереди.

Объект event

Модуль pygame.event для обработки очереди событий

pygame.event.pump	Если вы не используете другие функции событий в своей игре, вы должны вызвать pygame.event.pump (), чтобы позволить pygame обрабатывать внутренние действия
pygame.event.get	получает события из очереди
pygame.event.poll	получить одно событие из очереди
pygame.event.wait	ждёт одиночного события из очереди
pygame.event.peek	проверить, ждут ли очереди события определённого типа
pygame.event.clear	удалить все события из очереди
pygame.event.event_name	возвращает имя для типа события. Строка находится в стиле WordCap
pygame.event.set_blocked	проверяет, какие события не разрешены в очереди
pygame.event.set_allowed	проверяет, какие события разрешены в очереди
pygame.event.get_blocked	проверить, заблокирован ли тип события из очереди
pygame.event.set_grab	проверяет совместное использование устройств ввода с другими приложениями
pygame.event.get_grab	проверить, работает ли программа на устройствах ввода данных
pygame.event.post	поместить новое событие в очередь
pygame.event.Event	создать новый объект события
pygame.event.EventType	Объект Python, представляющий событие SDL. Экземпляры пользовательских событий создаются с вызовом функции Event. Тип EventType не может быть напрямую вызван. Экземпляры EventType поддерживают назначение и удаление атрибутов.

Pygame отслеживает все сообщения о событиях через очередь событий. Процедуры в этом модуле помогают управлять этой очередью событий. Входная очередь сильно зависит от модуля отображения (display) pygame. Если дисплей не был инициализирован и видеорежим не установлен, очередь событий не будет работать.

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

Мышь

Модуль pygame.mouse для работы с мышью

pygame.mouse.get_pressed	получить состояние кнопок мыши
pygame.mouse.get_pos	получить позицию курсора мыши
pygame.mouse.get_rel	получить количество движений мыши
pygame.mouse.set_pos	установить позицию курсора мыши
pygame.mouse.set_visible	скрыть или показать курсор мыши
pygame.mouse.get_focused	проверяет, принимает ли дисплей ввод мыши
pygame.mouse.set_cursor	установить изображение для курсора мыши
pygame.mouse.get_cursor	получить изображение для курсора мыши

Функции мыши можно использовать для получения текущего состояния устройства мышь. Эти функции также могут изменять курсор мыши.

Когда режим отображения (display) установлен, очередь событий начнет принимать события мыши. Кнопки мыши генерируют события pygame.MOUSEBUTTONDOWN и pygame.MOUSEBUTTONUP, когда они нажимаются и отпускаются. Эти события содержат атрибут кнопки, указывающий, какая кнопка была нажата. Колесо мыши будет генерировать pygame.MOUSEBUTTONDOWN и pygame.MOUSEBUTTONUP события при прокрутке.

Когда колесо повернуто вверх, кнопка будет установлена на 4, вниз -5. Всякий раз, когда мышь перемещается, генерируется событие pygame.MOUSEMOTION. Движение мыши разбито на небольшие и точные события движения. По мере перемещения мыши многие события движения будут помещены в очередь. События движения мыши, которые неправильно очищены от очереди событий, являются основной причиной того, что очередь событий заполняется.

Пример. Нарисовать курсор под текущей позицией мыши.

x, y = pygame.mouse.get_pos()
x -= mouse_cursor.get_width()/2
y -= mouse_cursor.get_height()/2
screen.blit(mouse_cursor, (x, y))

Определить какая кнопка была нажата на мышке можно используя значение event.button:

1 - left click
2 - middle click
3 - right click
4 - scroll up
5 - scroll down

Координаты курсора при нажатии кнопки мыши находятся в event.pos.

Пример. Перемещать картинку курсором мыши.

import pygame, sys, time
from pygame.locals import *
pygame.init()
FPS=30
fpsClock=pygame.time.Clock()
width=500
height=500
mainSurface=pygame.display.set_mode((width,height),0,32)
pygame.display.set_caption('Keyb moves')
background=pygame.image.load('images//bg1.jpg')
sprite=pygame.image.load('images//pict2.gif') 

# Place image to the center of mainSurface
image_pos = ((mainSurface.get_width() - sprite.get_width())/2, (mainSurface.get_height() - sprite.get_height())/2)
doMove = False

# game loop
while True:
    fpsClock.tick(FPS) # frame rate
    mainSurface.blit(background,(0,0))
    
    # get all events from the queue
    for event in pygame.event.get():
        # loop events queue
        if event.type == QUIT:
            # window close X pressed
            pygame.quit()
            sys.exit()

        if event.type == KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()

        if event.type == pygame.MOUSEBUTTONDOWN:
            if event.button == 1:  #  левая кнопка мыши
                doMove = True
            if event.button == 3:  # правая кнопка мыши
                image_pos = ((mainSurface.get_width() - sprite.get_width())/2, (mainSurface.get_height() - sprite.get_height())/2)
                doMove = False

        if event.type == pygame.MOUSEBUTTONUP: doMove = False
            
        if event.type == MOUSEMOTION and doMove:
            image_pos = event.pos

    mainSurface.blit(sprite,image_pos)
    pygame.display.update()

Клавиатура

Модуль pygame.key

Этот модуль содержит функции для работы с клавиатурой.Очередь событий получает события pygame.KEYDOWN и pygame.KEYUP при нажатии и отпускании клавиш клавиатуры.

Оба события имеют ключевой атрибут, который представляет собой целочисленный идентификатор, представляющий каждую клавишу на клавиатуре.Событие pygame.KEYDOWN имеет дополнительные атрибуты: unicode и scancode. unicode представляет собой одну символьную строку, которая соответствует введённому символу. Scancode представляет собой код для конкретной платформы.

Получить код клавиши:

pressed_keys = pygame.key.get_pressed()
if pressed_keys[K_SPACE]:
# Space key has been pressed
fire()

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

KeyASCII	ASCII	CommonName
K_BACKSPACE	\b	backspace
K_TAB	\t	tab
K_CLEAR		clear
K_RETURN	\r	return
K_PAUSE		pause
K_ESCAPE	^[	escape
K_SPACE		space
K_EXCLAIM	!	exclaim
K_QUOTEDBL	«	quotedbl
K_HASH	#	hash
K_DOLLAR	$	dollar
K_AMPERSAND	&	ampersand
K_QUOTE		quote
K_LEFTPAREN	(	leftparenthesis
K_RIGHTPAREN	)	rightparenthesis
K_ASTERISK	*	asterisk
K_PLUS	+	plussign
K_COMMA	,	comma
K_MINUS	—	minussign
K_PERIOD	.	period
K_SLASH	/	forwardslash
K_0	0	0
K_1	1	1
K_2	2	2
K_3	3	3
K_4	4	4
K_5	5	5
K_6	6	6
K_7	7	7
K_8	8	8
K_9	9	9
K_COLON	:	colon
K_SEMICOLON	;	semicolon
K_LESS		less-thansign
K_EQUALS	=	equalssign
K_GREATER	>	greater-thansign
K_QUESTION	?	questionmark
K_AT	@	at
K_LEFTBRACKET	[	leftbracket
K_BACKSLASH	\	backslash
K_RIGHTBRACKET	]	rightbracket
K_CARET	^	caret
K_UNDERSCORE	_	underscore
K_BACKQUOTE	`	grave
K_a	a	a
K_b	b	b
K_c	c	c
K_d	d	d
K_e	e	e
K_f	f	f
K_g	g	g
K_h	h	h
K_i	i	i
K_j	j	j
K_k	k	k
K_l	l	l
K_m	m	m
K_n	n	n
K_o	o	o
K_p	p	p
K_q	q	q
K_r	r	r
K_s	s	s
K_t	t	t
K_u	u	u
K_v	v	v
K_w	w	w
K_x	x	x
K_y	y	y
K_z	z	z
K_DELETE		delete
K_KP0		keypad0
K_KP1		keypad1
K_KP2		keypad2
K_KP3		keypad3
K_KP4		keypad4
K_KP5		keypad5
K_KP6		keypad6
K_KP7		keypad7
K_KP8		keypad8
K_KP9		keypad9
K_KP_PERIOD	.	keypadperiod
K_KP_DIVIDE	/	keypaddivide
K_KP_MULTIPLY	*	keypadmultiply
K_KP_MINUS	—	keypadminus
K_KP_PLUS	+	keypadplus
K_KP_ENTER	\r	keypadenter
K_KP_EQUALS	=	keypadequals
K_UP		uparrow
K_DOWN		downarrow
K_RIGHT		rightarrow
K_LEFT		leftarrow
K_INSERT		insert
K_HOME		home
K_END		end
K_PAGEUP		pageup
K_PAGEDOWN		pagedown
K_F1		F1
K_F2		F2
K_F3		F3
K_F4		F4
K_F5		F5
K_F6		F6
K_F7		F7
K_F8		F8
K_F9		F9
K_F10		F10
K_F11		F11
K_F12		F12
K_F13		F13
K_F14		F14
K_F15		F15
K_NUMLOCK		numlock
K_CAPSLOCK		capslock
K_SCROLLOCK		scrollock
K_RSHIFT		rightshift
K_LSHIFT		leftshift
K_RCTRL		rightcontrol
K_LCTRL		leftcontrol
K_RALT		rightalt
K_LALT		leftalt
K_RMETA		rightmeta
K_LMETA		leftmeta
K_LSUPER		leftWindowskey
K_RSUPER		rightWindowskey
K_MODE		modeshift
K_HELP		help
K_PRINT		printscreen
K_SYSREQ		sysrq
K_BREAK		break
K_MENU		menu
K_POWER		power
K_EURO		Euro

Направленное движение с помощью клавиш

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

Создать картинку, например:

sprite=pygame.image.load('images//pict2.gif')

Проверить очередь событий:

pygame.event.get()

Проверить, является ли полученное событие нажатием на клавиши со стрелками:

event.type == KEYDOWN

Если — да, то получмить код нажатой клавиши и сформировать новые координаты для картинки:

spritex,spritey

И нарисовать картинку в новом месте:

blit(sprite,(spritex,spritey))

import pygame, sys, time
from pygame.locals import *

pygame.init()

FPS=30
fpsClock=pygame.time.Clock()
width=500
height=500
mainSurface=pygame.display.set_mode((width,height),0,32)
pygame.display.set_caption('Keyb moves')

background=pygame.image.load('images//bg1.jpg')

sprite=pygame.image.load('images//pict2.gif') # Create moving image

# Place image to the center of mainSurface
spritex=(mainSurface.get_width() - sprite.get_width())/2
spritey=(mainSurface.get_height() - sprite.get_height())/2
direction=False

# --->
def move(direction, spritex, spritey):
    # This function moves recalculates new image coordinates
    if direction:
        if direction == K_UP:
            spritey-=5
        elif direction == K_DOWN:
            spritey+=5
        if direction == K_LEFT:
            spritex-=5
        elif direction == K_RIGHT:
            spritex+=5
    return spritex, spritey
# --->

# game loop
while True:
    fpsClock.tick(FPS) # define frame rate
    mainSurface.blit(background,(0,0))
    mainSurface.blit(sprite,(spritex,spritey))

    # get all events from the queue
    for event in pygame.event.get():
        # loop events queue, remember in 'direction' pressed key code
        if event.type==QUIT:
            # window close X pressed
            pygame.quit()
            sys.exit()
        if event.type==KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN: direction = event.key # Other key pressed
        if event.type == KEYUP:  direction = False # Key released

    # calculate new image position    
    spritex, spritey = move(direction, spritex, spritey)

    pygame.display.update()

Объект Surface

pygame.Surface — объект pygame для представления изображений

Surface((width, height), flags=0, depth=0, masks=None) -> Surface

Surface((width, height), flags=0, Surface) -> Surface

Наложение поверхностей, прозрачность.

#-*-coding: utf-8-*-
import pygame
pygame.init()

# Create base surface
screen = pygame.display.set_mode((500,500))

# Create new surface
surface1 = pygame.Surface((150,150))
surface1.fill((255,0,0))
surface1.set_alpha(150)
#
surface2 = pygame.Surface((100,100))
surface2.fill((255,255,0))
surface2.set_alpha(100)

# Create image
bgImg = pygame.image.load("images//bg3.jpg")
bgImg = pygame.transform.scale(bgImg,(500,500))
#
pict1 = pygame.image.load("images//pict1.jpg")
pict1 = pygame.transform.scale(pict1,(130,130))
pict1.set_alpha(100)
#
pict2 = pygame.image.load("images//pict2.gif")
pict2 = pygame.transform.scale(pict2,(50,50))

clock = pygame.time.Clock()
running = 1
dX = dY = 1
x = y = 0

while running:
    clock.tick(50)
    event = pygame.event.poll()
    if event.type == pygame.QUIT: running = 0
    x += 8 * dX
    y += 6 * dY
    if (y<0 or y>= (screen.get_height() - pict2.get_height())) :
        dY *= -1
    if (x<0 or x>= (screen.get_width() - pict2.get_width())) :
        dX *= -1
    
    screen.blit(bgImg,(0,0))
    surface1.blit(pict1,(0,0))
    screen.blit(surface1,(20,50))
    screen.blit(surface2,(150,150))
    screen.blit(pict2,(x,y))
    
    pygame.display.flip()

pygame.quit()

Управление временем

Модуль pygame.time содержит объект Clock, который можно использовать для отслеживания
времени. Чтобы создать объект типа: время, вызывается конструктор pygame.time.Clock:
clock = pygame.time.Clock()

Когда создан объект clock, можно вызвать его функцию tick один раз за кадр,
которая возвращает время, прошедшее со времени предыдущего вызова в миллисекундах:
time_passed = clock.tick ()

Функция tick может использовать необязательный параметр для установления максимальной частоты кадров. Этот параметр нужен, если игра запущена на рабочем компьютере и необходимо контролировать, чтобы она не использовала всю его вычислительная мощность на 100%:

# Игра будет работать со скоростью не более 30 кадров в секунду

time_passed = clock.tick (30)

Звуки

Для управления звуком используется модуль pygame.mixer. Он отвечает за любые действия со звуками.

Загружаем звуковой файл в формате *.wav

sound = pygame.mixer.Sound("sound.wav")
(загружаем до игрового цикла, т.к. это очень долгая операция)

Проигрываем звук

sound.play()

Столкновения (collisions)

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

Эта задача может быть реализована разными способами.

Например, используя объект Rect

#-*-coding:utf-8-*-
import pygame, sys, time
from pygame.locals import *

pygame.init()
FPS         = 30
fpsClock    = pygame.time.Clock()
winWidth    = 500
winHeight   = 500
mainSurface = pygame.display.set_mode((winWidth,winHeight),0,32)
pygame.display.set_caption('Collisions test')
background = pygame.image.load('images//bg1.jpg')

# Рисуем неподвижные компоненты на поверхности background
# Места расположения границ
border1Rect = pygame.Rect(0,0,100,500)
border2Rect = pygame.Rect(0,150,300,50)
# границы
border1 = pygame.draw.rect(background, (0,0,0), border1Rect, 0)
border2 = pygame.draw.rect(background, (0,0,0), border2Rect, 0)
# Записываем их в массив
borders = []
borders.append((border1,border1Rect))
borders.append((border2,border2Rect))
# Подвижный блок
blockWidth  = 50
blockHeight = 50
blockStep = 1
blockColor  = (255,0,0)
# Начальные координаты подвижного блока - по центру 
blockX = (mainSurface.get_width()   - blockWidth)/2
blockY = (mainSurface.get_height()  - blockHeight)/2
blockPosition = (blockX, blockY)
direction = False

# описание функции --->
def newPosition(dirFlag, pos):
    (x,y) = pos
    # Функция пересчитывает координаты для подвижного объекта
    if dirFlag:
        if dirFlag      == K_UP:
            y -= blockStep
        elif dirFlag    == K_DOWN:
            y += blockStep
        if dirFlag      == K_LEFT:
            x -= blockStep
        elif dirFlag    == K_RIGHT:
            x += blockStep
    return (x, y)
# --->

while True:   # Игра - начало
    # Частота обновления экрана
    fpsClock.tick(FPS)
    # Рисуем неподвижные компоненты
    mainSurface.blit(background,(0,0))
    # Рисуем подвижный компонент
    blockRect = pygame.Rect(blockPosition, (blockWidth, blockHeight))
    block = pygame.draw.rect(mainSurface, blockColor, blockRect, 1)
    # просматриваем очередь событий
    for event in pygame.event.get():
        # loop events queue, remember in 'direction' pressed key code
        if event.type == QUIT:
            # window close X pressed
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN: direction = event.key # Other key pressed
        if event.type == KEYUP:  direction = False # Key released
    # Cохраняем старые координаты подвижного блока
    savedPosition = blockPosition
    # Рассчитываем новые координаты подвижного блока
    blockPosition = newPosition(direction, blockPosition)
    # Проверяем их корректность 
    for border in borders:
        testRect = pygame.Rect(blockPosition, (blockWidth, blockHeight))  
        if testRect.colliderect(border[1]):
            print ("Столкновение !")
            # Возвращаем старые координату
            blockPosition = savedPosition
        else: print ("ok")
    pygame.display.update()
# Игра - конец

Или используя поверхности — surface

#-*-coding:utf-8-*-
import pygame, sys, time
from pygame.locals import *

# Блоки-ограничители рисуются как отдельные поверхности
# Между ними курсором перемещаем мячик

FPS = 30 # кадров в сек
# Размеры окна игры
width  = 500
height = 500
# Заголовок окна игры
title = "Collisions detection test"
# Сообщение в консоль игры
info = "Нет столкновений \n"
# Переменная - индикатор движения
direction = False
# Шаг движения
myStep = 2
pygame.mixer.init()
pygame.mixer.music.load("voice-prompts-reaction-reaction-1-child-3-yrs-oops-human-voice-kid-speak-talk.mp3")

pygame.init()
fpsClock = pygame.time.Clock()
mainSurface=pygame.display.set_mode((width,height),0,32)
pygame.display.set_caption(title)
background=pygame.image.load('images//bg1.jpg')     # Фон 
sprite = pygame.image.load('images//pict2.gif')     # Подвижная картинка

# Начальные координаты подвижной картинки
# Важно, чтобы в начале работы она не перекрывала ни один блок
spriteX=mainSurface.get_width() - sprite.get_width()
spriteY=mainSurface.get_height() - sprite.get_height()

# Неподвижные блоки - все сохраняем в одном списке
# Структура списка blocks:
# каждый элемент - пара значений: (поверхность, область её размещения)
# blocks[0] - первый элемент списка, blocks[0][0] - surface первого элемента,blocks[0][1]  - Rect первого элемента
blocks = []
block1 = pygame.Surface((200,200))
block1.set_alpha(80)
block1.fill((255,0,0))
block1Rect = pygame.Rect(0,0,block1.get_width(), block1.get_height())
blocks.append((block1,block1Rect))
#
block2 = pygame.Surface((100,200))
block2.fill((0,255,0))
block2Rect = pygame.Rect(400,0,block2.get_width(), block2.get_height())
blocks.append((block2,block2Rect))
#
block3 = pygame.Surface((300,100))
block3.fill((0,0,255))
block3Rect = pygame.Rect(0,350,block3.get_width(), block3.get_height())
blocks.append((block3,block3Rect))
# закончили с описанием 3-х блоков


# *********>
def newPosition (direction, spriteX, spriteY):
    # Функция пересчитывает координаты новой позиции подвижного объекта
    # Проверяем столкновений со всеми блоками-границаи
    global myStep
    if direction:
        if direction == K_UP:
            spriteY -= myStep
        elif direction == K_DOWN:
            spriteY += myStep
        elif direction == K_LEFT:
            spriteX -= myStep
        elif direction == K_RIGHT:
            spriteX += myStep
    return spriteX, spriteY
# *********>



# *********>
def collisionDetected():
    global blocks
    global spriteRectNew
    colFlag = False
    # Проверка столкновений со всеми блоками в массиве блоков
    for block in blocks:
        if spriteRectNew.colliderect(block[1]):
            collisionDir = direction
            colFlag = True
    return colFlag
# *********>

# Цикл игры
while True:
    fpsClock.tick(FPS) # Частота обновления экрана
    
    # Обрабатываем очередь событий - начало 
    for event in pygame.event.get(): 
        # В цикле берём из очереди очередное событие, запоминаем в переменной event
        # Проверяем тип события и выполняем соответствующие лействия
        if event.type == QUIT:
            # Тип проверяемого события НАЖАТ Х В ОКНЕ ИГРЫ
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()

        # Следующая строка получает управление только тогда, когда не отработали предыдущие проверки кода события
        # то есть произошло событие, отличное от перечисленных выше
        if event.type == KEYDOWN:
            direction = event.key
        if event.type == KEYUP:
            direction = False # Кнопка отпущена
    # Обрабатываем очередь событий - конец 


    # Текущее место расположения подвижной картинки 
    spriteRect = pygame.Rect(spriteX,spriteY,sprite.get_width(), sprite.get_height())

    # Сохраняем старые координаты
    oldPos = (spriteX, spriteY)
    
    # Вычмсляем новые координаты, анализируя нажатые кнопки
    spriteX, spriteY = newPosition(direction, spriteX, spriteY)

    # Вычисляем новое место расположения картинки
    spriteRectNew = pygame.Rect(spriteX,spriteY,sprite.get_width(), sprite.get_height())

    
    # Проверяем, не пересекает ли новое место блоки. Если пересекает, то вовращпни картинке старые координаты
    if collisionDetected():
        (spriteX, spriteY) = oldPos
        # Play OOPS!
        pygame.mixer.music.play()
        
    # Рисуем всё на экране
    #    Фон 
    mainSurface.blit(background,(0,0))
    #    Блоки 
    for block in blocks:
        mainSurface.blit(block[0],(block[1].x,block[1].y))
    #    Картинку 
    mainSurface.blit(sprite,(spriteRect.x,spriteRect.y))
    #    Обновляем экран
    pygame.display.update()