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

Документирование кода в Python. PEP 257

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

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

PEP 257 описывает соглашения, связанные со строками документации python, рассказывает о том, как нужно документировать python код.

Цель этого PEP — стандартизировать структуру строк документации: что они должны в себя включать, и как это написать (не касаясь вопроса синтаксиса строк документации). Этот PEP описывает соглашения, а не правила или синтаксис.

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

Что такое строки документации?

Строки документации — строковые литералы, которые являются первым оператором в модуле, функции, классе или определении метода. Такая строка документации становится специальным атрибутом __doc__ этого объекта.

Все модули должны, как правило, иметь строки документации, и все функции и классы, экспортируемые модулем также должны иметь строки документации. Публичные методы (в том числе __init__) также должны иметь строки документации. Пакет модулей может быть документирован в __init__.py.

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

Существует две формы строк документации: однострочная и многострочная.

Однострочные строки документации

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

def kos_root():
    """Return the pathname of the KOS root directory."""
    global _kos_root
    if _kos_root: return _kos_root

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

Закрывающие кавычки на той же строке. Это смотрится лучше.

Нет пустых строк перед или после документации.

Однострочная строка документации не должна быть «подписью» параметров функции / метода (которые могут быть получены с помощью интроспекции). Не делайте:

def function(a, b):
    """function(a, b) -> list"""

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

def function(a, b):
    """Do X and return a list."""

(Конечно, «Do X» следует заменить полезным описанием!)

Многострочные строки документации

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

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

Строки документации скрипта (самостоятельной программы) должны быть доступны в качестве «сообщения по использованию», напечатанной, когда программа вызывается с некорректными или отсутствующими аргументами (или, возможно, с опцией «-h», для помощи). Такая строка документации должна документировать функции программы и синтаксис командной строки, переменные окружения и файлы. Сообщение по использованию может быть довольно сложным (несколько экранов) и должно быть достаточным для нового пользователя для использования программы должным образом, а также полный справочник со всеми вариантами и аргументами для искушенного пользователя.

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

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

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

Если класс — подкласс другого класса, и его поведение в основном унаследовано от этого класса, строки документации должны отмечать это и обобщить различия. Используйте глагол «override», чтобы указать, что метод подкласса заменяет метод суперкласса и не вызывает его; используйте глагол «extend», чтобы указать, что метод подкласса вызывает метод суперкласса (в дополнение к собственному поведению).

И, напоследок, пример:

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)

    """
    if imag == 0.0 and real == 0.0: return complex_zero
    ...

А ещё больше примеров можно посмотреть в стандартной библиотеке Python (например, в папке Lib вашего интерпретатора Python).

Оригинал

Быстрый старт с 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 и сэкономит вам бесчисленные часы в будущем. Удачного программирования!

Hello, World или 5 шагов в Github

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

Проект Hello World — давняя традиция в компьютерном мире. Традиционно, с этого простого упражнения вы начинаете постигать что-то новое. Давайте начнем знакомится с GitHub!

Вы узнаете,

как создать и использовать репозиторий;
как создать и управлять новой веткой;
как внесите изменения в файл и отправлять их на GitHub в качестве коммитов;
как создать и объединить запрос на подключение.

Что такое GitHub?

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

Здесь вы узнаете основы GitHub, что такое репозитории, ветки, коммиты и запросы на подключение. Вы создадите свой собственный репозиторий Hello World и поймете рабочий процесс GitHub’s Pull Request, популярный способ создания и просмотра кода.

Нет необходимости кодировать

Чтобы пройти этот урок, нужна учетная запись на GitHub.com и доступ в Интернет. Не нужно знать, как кодировать, использовать командную строку или устанавливать Git (программное обеспечение для контроля версий, на котором построен GitHub).

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

Делай 1. Создайте репозиторий

Хранилище обычно используется для организации проекта. Репозитории могут содержать папки и файлы, изображения, видео, электронные таблицы и наборы данных — все, что нужно вашему проекту. Мы рекомендуем начать с файла README или с файл, содержащего описание и информацию о вашем проекте. В GitHub это делается очень просто при создании своего нового репозитория. Кроме того, предлагается описать другие общие атрибуты проекта, например, файл лицензии.

Ваш репозиторий hello-world может быть местом, где вы храните свои идеи, ресурсы или делитесь и обсуждаете полезные вещи с другими.

Создать новый репозиторий

В правом верхнем углу, рядом с вашим аватаром или идентификатором, нажмите и затем выберите New repository.
Назовите свой репозиторий hello-world.
Сделайте краткое описание.
Выберите Initialize this repository with a README.

Создание репозитаррия

Нажмите Create repository..

Делай 2. Создайте ветку

Ветвление — способ одновременной работы с разными версиями хранилища.

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

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

На диаграмме показано:

master филиал.
Новая ветвь под названием feature (после выполнения ‘Feature Work‘ в этой ветке).
Траектория, по которое проходит ветка feature прежде чем она объединится с master.

Ветки репозитария Github

Вы когда-нибудь сохраняли разные версии файла? Например:

story.txt
story-joe-edit.txt
story-joe-edit-reviewed.txt

Это аналогично в репозиториях GitHub.

Здесь, на GitHub, наши разработчики, писатели и дизайнеры используют ветки для хранения исправлений ошибок и работы с функциями отдельно от нашей master(производственной) ветки. Когда изменение закончены, они объединяют c веткой с master.

Создать новую ветку

Зайдите в свой новый репозиторий hello-world.
Нажмите на раскрывающийся список в верхней части списка файлов с надписью branch: master.
Введите название ветви readme-edits в текстовое поле новой ветви.
Выберите синий бокс Create branch или нажмите «Enter» на клавиатуре.

Создать новую ветку

Теперь у вас есть две ветки: master и readme-edits. Они выглядят точно так же, но не надолго! Далее мы добавим свои изменения в новую ветку.

Делай 3. Внесите и сохраните изменения

Браво! Теперь вы находитесь в вашей ветке readme-edits, которая является копией master. Давайте внесем некоторые изменения.

На GitHub сохраненные изменения называются commits. Каждый commit имеет соответствующее commit message, которое представляет собой комментарий к сделанным конкретным изменениям. Сообщения регистрируются в историю ваших изменений для того, чтобы другие участники могли понять, что же вы сделали и почему.

Вносить и фиксировать изменения

Нажмите на файл README.md.
Нажмите на значок карандаша в правом верхнем углу окна файла для редактирования.
В редакторе напишите немного о себе.
Напишите commit, который описывает ваши изменения.
Нажмите кнопку «Commit changes».

Фиксируем изменения

Эти изменения будут внесены только в файл README в вашей ветви readme-edits, так что теперь эта ветвь содержит контент, отличный от master.

Делай 4. Откройте запрос на извлечение

Хорошие правки! Теперь, когда у вас есть изменения в ветке отличной от master, вы можете открыть pull request.

Pull Requests — это сердце сотрудничества на GitHub. Когда вы открываете Pull Requests, вы предлагаете свои изменения и просите, чтобы кто-то проверил и внес их в свою ветку. Pull Requests показывают различия в содержимом обеих веток. Изменения, дополнения и удаления показаны зеленым и красным.

Как только вы сделаете Commit, вы можете открыть Pull Requests и начать обсуждение, даже при незавершенном коде.

Используя систему @mention от GitHub в своем сообщении о Pull Requests, вы можете попросить обратную связь от конкретных людей или команд, вне зависимости от того, находятся они рядом или в 10 часовых поясах.

Вы даже можете открывать Pull Requests в своем собственном репозитории и объединять их самостоятельно. Это отличный способ изучить поток GitHub перед началом работы над большими проектами.

Откройте Pull Requests в README

Когда вы закончите со своим сообщением, нажмите Create pull request!

Совет : вы можете использовать эмодзи и перетаскивать изображения и картинки в Commit и Pull request.

Делай 5. Объедините свой Pull request

На этом последнем этапе пришло время объединить ваши изменения — ветку readme-edits c веткой master.

Нажмите зелёную кнопку Merge pull request button для переноса изменений в master.
Нажмите Confirm merge.
Продолжите и удалите свою ветку, так как изменения сохранены в master, для чего нажмите кнопку Delete branch в фиолетовом поле.

Идите дальше и удалите ветку, так как ее изменения были включены, с помощью кнопки Удалить ветку в фиолетовом поле.

Слияние своей ветки с веткой master

Удаление ветки readme-edits

Радуйтесь!

Сделав это упражнение, вы научились создавать проект и отправлять запросы на GitHub!

Вот результат урока:

Создан репозиторий с открытым исходным кодом
Начал и управлял новым филиалом
Изменил файл и передал эти изменения в GitHub
Открыт и объединен запрос на извлечение
Взгляните на свой профиль GitHub, и вы увидите ваши новые квадраты вклада !

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

Совет : ознакомьтесь с другими нашими руководствами, каналом YouTube и обучением по требованию, чтобы узнать больше о том, как начать работу с GitHub.

Перевод: Hello World

Встроенные функции Python: какие нужно просто знать

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

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

Чтобы разобраться, на какие функции стоит обратить внимание, их следует разделить на группы:

общеизвестные: почти все новички используют эти функции и довольно часто (print, len, str, int, float, list, tuple, dict, set, range);
неочевидные для новичков: об этих функциях полезно знать, но их легко пропустить, когда вы новичок в Python (bool, enumerate, zip, reversed, sum, min и max, sorted, any и all);
понадобятся позже: об этих встроенных функциях полезно помнить, чтобы найти их потом, когда/если они понадобятся (open, input, repr, super, property, issubclass и isinstance, hasattr, getattr, setattr и delattr, classmethod и staticmethod, next);
можно изучить когда-нибудь: это может пригодиться, но только при определённых обстоятельствах;
скорее всего, они вам не нужны: они вряд ли понадобятся, если вы не занимаетесь чем-то достаточно специализированным.

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

Общеизвестные функции

Если вы уже писали код на Python, эти модули должны быть вам знакомы.

print

Вряд ли найдётся разработчик, даже начинающий, который не знает эту функцию вывода. Как минимум реализация «Hello, World!» требует использования данного метода. Но вы можете не знать о различных аргументах, которые можно передавать в print.

>>> words = ["Welcome", "to", "Python"]
>>> print(words)
['Welcome', 'to', 'Python']
>>> print(*words, end="!\n")
Welcome to Python!
>>> print(*words, sep="\n")
Welcome
to
Python

len

В Python нет синтаксиса вроде my_list.length() или my_string.length, вместо этого используются поначалу непривычные конструкции len(my_list) и len(my_string).

>>> words = ["Welcome", "to", "Python"]
>>> len(words)

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

str

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

>>> version = 3
>>> "Python " + version
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str

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

>>> version = 3
>>> "Python " + str(version)
'Python 3'

int

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

>>> program_name = "Python 3"
>>> version_number = program_name.split()[-1]
>>> int(version_number)
3

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

>>> from math import sqrt
>>> sqrt(28)
5.291502622129181
>>> int(sqrt(28))
5

Обратите внимание, если нужно обрезать дробную часть при делении, оператор «//» более уместен (с отрицательными числами это работает иначе).

int (3/2) == 3 // 2

float

Если строка, которую надо конвертировать в число, не является целым числом, здесь поможет метод float.

>>> program_name = "Python 3"
>>> version_number = program_name.split()[-1]
>>> float(version_number)
3.0
>>> pi_digits = '3.141592653589793238462643383279502884197169399375'
>>> len(pi_digits)
50
>>> float(pi_digits)
3.141592653589793

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

В Python 2 такое преобразование необходимо, но в Python 3 целочисленное деление больше не является чем-то особенным (если вы специально не используете оператор «//»). Поэтому больше не нужно использовать float для этой цели, теперь float(x)/y можно легко заменить на x/y.

list

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

>>> numbers = [2, 1, 3, 5, 8]
>>> squares = (n**2 for n in numbers)
>>> squares
 at 0x7fd52dbd5930>
>>> list_of_squares = list(squares)
>>> list_of_squares
[4, 1, 9, 25, 64]

При работе со списком метод copy позволяет создать его копию.

>>> copy_of_squares = list_of_squares.copy()

Если вы не знаете, с какими элементами работаете, функция list является более общим способом перебора элементов и их копирования.

>>> copy_of_squares = list(list_of_squares)

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

Обратите внимание, когда вы хотите создать пустой список, следует использовать буквальный синтаксис списка («[ ]»).

>>> my_list = list()  # Так делать нельзя
>>> my_list = []      # Так можно

Использование «[ ]» считается более идиоматическим, так как эти скобки на самом деле выглядят как список Python.

tuple

Эта функция во многом похожа на функцию list, за исключением того, что вместо списков она создает кортежи.

>>> numbers = [2, 1, 3, 4, 7]
>>> tuple(numbers)
(2, 1, 3, 4, 7)

Если вы пытаетесь создать хешируемую коллекцию (например, ключ словаря), стоит отдать предпочтению кортежу вместо списка.

dict

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

>>> color_counts = [('red', 2), ('green', 1), ('blue', 3), ('purple', 5)]

Выведем его на экран с помощью цикла.

>>> colors = {}
>>> for color, n in color_counts:
...     colors[color] = n
...
>>> colors
{'red': 2, 'green': 1, 'blue' 3, 'purple': 5}>

То же самое, но с использованием dist.

>>> colors = dict(color_counts)
>>> colors
{'red': 2, 'green': 1, 'blue' 3, 'purple': 5}>

Функция dist может принимать 2 типа аргументов:

другой словарь: в этом случае этот словарь будет скопирован;
список кортежей «ключ-значение»: в этом случае из этих слов будет создан новый словарь.

Поэтому следующий код также будет работать.

>>> colors
{'red': 2, 'green': 1, 'blue' 3, 'purple': 5}
>>> new_dictionary = dict(colors)
>>> new_dictionary
{'red': 2, 'green': 1, 'blue' 3, 'purple': 5}

Функция dict также может принимать ключевые слова в качестве аргументов для создания словаря со строковыми ключами.

>>> person = dict(name='Trey Hunner', profession='Python Trainer')
>>> person
{'name': 'Trey Hunner', 'profession': 'Python Trainer'}

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

>>> person = {'name': 'Trey Hunner', 'profession': 'Python Trainer'}
>>> person
{'name': 'Trey Hunner', 'profession': 'Python Trainer'}

Такой синтаксис более гибок и немного быстрее. Но самое главное он более чётко передаёт факт того, что вы создаёте именно словарь.

Как в случае со списком и кортежем, пустой словарь следует создавать с использованием буквального синтаксиса («{}»).

>>> my_list = dict()  # Так делать нельзя
>>> my_list = {}  # Так можно

Использование «{}» более идиоматично и эффективно с точки зрения использования процессора. Обычно для создания словарей используются фигурные скобки, dict встречается гораздо реже.

set

Функция set создаёт новый набор. Она принимает итерации из хешируемых значений (строк, чисел или других неизменяемых типов) и возвращает set.

>>> numbers = [1, 1, 2, 3, 5, 8]
>>> set(numbers)
{1, 2, 3, 5, 8}

Создать пустой набор с «{}» нельзя (фигурные скобки создают пустой словарь). Поэтому функция set — лучший способ создать пустой набор.

>>> numbers = set()
>>> numbers
set()

Можно использовать и другой синтаксис.

>>> {*()}  # Так можно создать пустой набор
set()

Такой способ имеет недостаток — он сбивает с толку (он основан на редко используемой функции оператора *), поэтому он не рекомендуется.

range

Эта функция создаёт объект range, который представляет собой диапазон чисел.

>>> range(10_000)
range(0, 10000)
>>> range(-1_000_000_000, 1_000_000_000)
range(-1000000000, 1000000000)

Результирующий диапазон чисел включает начальный номер, но исключает конечный (range(0, 10) не включает 10). Данная функция полезна при переборе чисел.

>>> for n in range(0, 50, 10):
...     print(n)
...
0
10
20
30
40

Обычный вариант использования — выполнить операцию n раз.

first_five = [get_things() for _ in range(5)]

Функция range в Python 2 возвращает список. Это означает, что примеры кода выше будут создавать очень большие списки. Range в Python 3 работает как xrange в Python 2. Числа вычисляются «более лениво» при проходе по диапазону.

Функции, неочевидные для новичков

bool

Эта функция проверяет достоверность (истинность) объектов Python. Относительно чисел будет выполняться проверка на неравенство нулю.

>>> bool(5)
True
>>> bool(-1)
True
>>> bool(0)
False

Применяя bool к коллекциям, будет проверяться их длина (больше 0 или нет).

>>> bool('hello')
True
>>> bool('')
False
>>> bool(['a'])
True
>>> bool([])
False
>>> bool({})
False
>>> bool({1: 1, 2: 4, 3: 9})
True
>>> bool(range(5))
True
>>> bool(range(0))
False
>>> bool(None)
False

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

# Вместо этого
if len(numbers) == 0:
    print("The numbers list is empty")

# многие делают так
if not numbers:
    print("The numbers list is empty")

Данная функция используется редко. Но, если нужно привести значение к логическому типу для проверки его истинности, bool вам необходима.

enumerate

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

>>> with open('hello.txt', mode='rt') as my_file:
...     for n, line in enumerate(my_file, start=1):
...         print(f"{n:03}", line)
...
001 This is the first line of the file
002 This is the second line
003 This is the last line of the file

Enumerate также часто используется для отслеживания индекса элементов в последовательности.

def palindromic(sequence):
    """Возвращает True, если последовательность является палиндромом."""
    for i, item in enumerate(sequence):
        if item != sequence[-(i+1)]:
            return False
    return True

Также следует обратить внимание, что новички в Python часто используют range(len(sequence)). Если вы когда-нибудь встретите конструкции типа range(len(...)), лучше заменить её на enumerate. Она поможет упростить конструкцию операторов.

def palindromic(sequence):
    """Возвращает True, если последовательность является палиндромом."""
    for i in range(len(sequence)):
        if sequence[i] != sequence[-(i+1)]:
            return False
    return True

zip

Эта функция ещё более специализирована, чем enumerate. Zip используется для перебора сразу нескольких объектов одновременно.

>>> one_iterable = [2, 1, 3, 4, 7, 11]
>>> another_iterable = ['P', 'y', 't', 'h', 'o', 'n']
>>> for n, letter in zip(one_iterable, another_iterable):
...     print(letter, n)
...
P 2
y 1
t 3
h 4
o 7
n 11

По сравнению с enumerate, последняя функция удобна, когда нужна индексация во время цикла. Если нужно обрабатывать несколько объектов одновременно, zip предпочтительнее enumerate.

reversed

Функция reversed, как enumerate и zip, возвращает итератор.

>>> numbers = [2, 1, 3, 4, 7]
>>> reversed(numbers)

Единственное, что можно сделать с этим итератором, пройтись по нему (но только один раз).

>>> reversed_numbers = reversed(numbers)
>>> list(reversed_numbers)
[7, 4, 3, 1, 2]
>>> list(reversed_numbers)
[]

Подобно enumerate и zip, reversed является своего рода вспомогательной функцией в циклах. Её использование можно увидеть исключительно в цикле for.

>>> for n in reversed(numbers):
...     print(n)
...
7
4
3
1
2

Есть несколько и других способов перевернуть списки в Python.

# Синтаксис нарезки
for n in numbers[::-1]:
    print(n)

# Метод переворота на месте
numbers.reverse()
for n in numbers:
    print(n)

Данная функция, как правило, является лучшим способом «перевернуть» любой список (а также набор, массив и т. д.) в Python. В отличие от numbers.reverse(), reversed не изменяет список, а возвращает итератор перевёрнутых элементов. reversed(numbers) (в отличие от numbers [::-1]) не создает новый список. Возвращаемый им итератор извлекает следующий элемент в обратном порядке при проходе по циклу. Также синтаксис reversed(numbers) намного более читабелен, чем numbers [::-1].

Можно использовать факт, что reversed не копирует список. Если объединить его с функцией zip, можно переписать функцию palindromic (из раздела enumerate), не занимая дополнительной памяти (не копируя объект).

def palindromic(sequence):
    """Возвращает True, если последовательность является палиндромом."""
    for n, m in zip(sequence, reversed(sequence)):
        if n != m:
            return False
    return True

sum

Эта функция берёт набор чисел и возвращает их сумму.

>>> sum([2, 1, 3, 4, 7])
17

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

>>> numbers = [2, 1, 3, 4, 7, 11, 18]
>>> sum(n**2 for n in numbers)
524

min и max

Эти функции выдают минимальное и максимальное число из набора соответственно.

>>> numbers = [2, 1, 3, 4, 7, 11, 18]
>>> min(numbers)
1
>>> max(numbers)
18

Данные методы сравнивают элементы, используя оператор <. Поэтому, все передаваемые в них значения должны быть упорядочены и сопоставимы друг с другом. Min и max также принимают key-свойство, позволяющее настроить, что на самом деле означают «минимум» и «максимум» для конкретных объектов.

>>> fruits = ['kumquat', 'Cherimoya', 'Loquat', 'longan', 'jujube']
>>> sorted(fruits, key=len)
['Loquat', 'longan', 'jujube', 'kumquat', 'Cherimoya']

sorted

Эта функция принимает любой набор элементов и возвращает новый список всех значений в отсортированном порядке.

>>> numbers = [1, 8, 2, 13, 5, 3, 1]
>>> words = ["python", "is", "lovely"]
>>> sorted(words)
['is', 'lovely', 'python']
>>> sorted(numbers, reverse=True)
[13, 8, 5, 3, 2, 1, 1]

Данная функция (как min и max) сравнивает элементы, используя оператор <, поэтому все значения, переданные ей, должны быть упорядочены. Sorted также позволяет настраивать сортировку с помощью key-свойства.

any и all

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

Используя all, можно переписать функцию palindromic следующим образом.

def palindromic(sequence):
    """Возвращает True, если последовательность является палиндромом."""
    return all(
        n == m
        for n, m in zip(sequence, reversed(sequence))
    )

Отрицание условия и возвращаемого значения позволит также использовать any в этом примере точно также (что усложнит конструкцию, но вполне сойдёт в качестве примера использования).

def palindromic(sequence):
    """Возвращает True, если последовательность является палиндромом."""
    return not any(
        n != m
        for n, m in zip(sequence, reversed(sequence))
    )

5 функций для отладки

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

breakpoint

Если нужно приостановить выполнение кода и перейти в командную строку Python, эта функция вам пригодится. Вызов breakpoint перебросит вас в отладчик Python. Эта встроенная функция была добавлена в Python 3.7, но если вы работаете в более старых версиях, можете получить тот же результат с помощью import pdb; pdb.set_trace().

dir

Эта функция может использоваться в двух случаях:

просмотр списка всех локальных переменных;
просмотр списка всех атрибутов конкретного объекта.

Из примера можно увидеть локальные переменные сразу после запуска и после создания новой переменной x.

>>> dir()
['__annotations__', '__doc__', '__name__', '__package__']
>>> x = [1, 2, 3, 4]
>>> dir()
['__annotations__', '__doc__', '__name__', '__package__', 'x']

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

>>> dir(x)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

В выведенном списке атрибутов можно увидеть его типичные методы (append, pop, remove и т. д.) , а также множество более сложных методов для перегрузки операторов.

vars

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

>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': }

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

>>> from itertools import chain
>>> vars(chain)
mappingproxy({'__getattribute__': , '__iter__': , '__next__': , '__new__': , 'from_iterable': , '__reduce__': , '__setstate__': , '__doc__': 'chain(*iterables) --> chain object\n\nReturn a chain object whose .__next__() method returns elements from the\nfirst iterable until it is exhausted, then elements from the next\niterable, until all of the iterables are exhausted.'})

Перед использованием vars было бы неплохо сначала обратиться к dir.

type

Эта функция возвращает тип объекта, который вы ей передаете.

Тип экземпляра класса есть сам класс.

>>> x = [1, 2, 3]
>>> type(x)

Тип класса — это его метакласс, обычно это type.

>>> type(list)

>>> type(type(x))

Атрибут __class__ даёт тот же результат, что и функция type, но рекомендуется использовать второй вариант.

>>> x.__class__
>>> type(x)

Функция type, кроме отладки, иногда полезна и в реальном коде (особенно в объектно-ориентированном программировании с наследованием и пользовательскими строковыми представлениями). Обратите внимание, что при проверке типов обычно вместо type используется функция isinstance. Также стоит понимать, что в Python обычно не принято проверять типы объектов (вместо этого практикуется утиная типизация).

help

Если вы находитесь в Python Shell или делаете отладку кода с использованием breakpoint, и хотите знать, как работает определённый объект, метод или атрибут, функция help поможет вам. В действительности вы, скорее всего, будете обращаться за помощью к поисковой системе. Но если вы уже находитесь в Python Shell, вызов help(list.insert) будет быстрее, чем поиск документации в Google.

Функции, которые пригодятся позже

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

open

Эта функция служит для открытия файла и последующей работы с ним. Но, если вы не работаете с файлами напрямую, то она вам может и не пригодиться. Несмотря на то, что работа с файлами очень распространена, далеко не все программисты Python работают с файлами через open. Например, разработчики Django могут не использовать её вообще.

input

Эта функция запрашивает у пользователя ввод, ждёт нажатия клавиши Enter, а затем возвращает набранный текст. Чтение из стандартного ввода — это один из способов получить входные данные в программе. Но есть и много других способов: аргументы командной строки, чтение из файла, чтение из базы данных и многое другое.

repr

Эта функция необходима для представления объекта в читабельном виде. Для многих объектов функции str и repr работают одинаково.

>>> str(4), repr(4)
('4', '4')
>>> str([]), repr([])
('[]', '[]')

Но есть объекты, для которых их применение различается.

>>> str('hello'), repr("hello")
('hello', "'hello'")
>>> from datetime import date
>>> str(date(2020, 1, 1)), repr(date(2020, 1, 1))
('2020-01-01', 'datetime.date(2020, 1, 1)')

Строковое представление, которое вы видите в Python Shell, использует repr, тогда как функция print использует str.

>>> date(2020, 1, 1)
datetime.date(2020, 1, 1)
>>> "hello!"
'hello!'
>>> print(date(2020, 1, 1))
2020-01-01
>>> print("hello!")
hello!

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

super

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

property

Эта функция является декоратором и дескриптором.

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

class Circle:

    def __init__(self, radius=1):
        self.radius = radius

    @property
    def diameter(self):
        return self.radius * 2

Здесь вы можете увидеть доступ к атрибуту diameter объекта Circle.

>>> circle = Circle()
>>> circle.diameter
2
>>> circle.radius = 5
>>> circle.diameter
10

Если вы занимаетесь объектно-ориентированным программированием на Python, вам, вероятно, захочется узнать о property больше в какой-то момент. В отличие от других объектно-ориентированных языков, в Python property используется вместо методов getter и setter.

issubclass и isinstance

Функция issubclass проверяет, является ли класс подклассом одного или нескольких других классов.

>>> issubclass(int, bool)
False
>>> issubclass(bool, int)
True
>>> issubclass(bool, object)
True

Функция isinstance проверяет, является ли объект экземпляром одного или нескольких классов.

>>> isinstance(True, str)
False
>>> isinstance(True, bool)
True
>>> isinstance(True, int)
True
>>> isinstance(True, object)
True

Функция isinstance может быть представлена как делегирование в issubclass.

>>> issubclass(type(True), str)
False
>>> issubclass(type(True), bool)
True
>>> issubclass(type(True), int)
True
>>> issubclass(type(True), object)
True

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

hasattr, getattr, setattr и delattr

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

>>> class Thing: pass
...
>>> thing = Thing()

Функция hasattr позволяет проверить, имеет ли объект определённый атрибут.

>>> hasattr(thing, 'x')
False
>>> thing.x = 4
>>> hasattr(thing, 'x')
True

Функция getattr позволяет получить значение атрибута (с необязательным значением по умолчанию, если атрибут не существует).

>>> getattr(thing, 'x')
4
>>> getattr(thing, 'x', 0)
4
>>> getattr(thing, 'y', 0)
0

Функция setattr позволяет установить значение атрибута.

>>> setattr(thing, 'x', 5)
>>> thing.x
5

И delattr соответственно удаляет атрибут.

>>> delattr(thing, 'x')
>>> thing.x
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'Thing' object has no attribute 'x'>

classmethod и staticmethod

Если у вас есть метод, который должен вызываться в экземпляре или в классе, вам нужен декоратор classmethod. Фабричные методы (альтернативные конструкторы) являются распространённым случаем для этого.

class RomanNumeral:

    """Римская цифра, представленная как строка и число."""

    def __init__(self, number):
        self.value = number

    @classmethod
    def from_string(cls, string):
        return cls(roman_to_int(string))  # Функция пока еще не существует

Немного сложнее придумать хорошее использование staticmethod, так как всегда можно использовать функцию уровня модуля вместо статического метода.

class RomanNumeral:

    """Римская цифра, представленная как строка и число."""

    SYMBOLS = {'M': 1000, 'D': 500, 'C': 100, 'L': 50, 'X': 10, 'V': 5, 'I': 1}

    def __init__(self, number):
        self.value = number

    @classmethod
    def from_string(cls, string):
        return cls(cls.roman_to_int(string))

    @staticmethod
    def roman_to_int(numeral):
        total = 0
        for symbol, next_symbol in zip_longest(numeral, numeral[1:]):
            value = RomanNumeral.SYMBOLS[symbol]
            next_value = RomanNumeral.SYMBOLS.get(next_symbol, 0)
            if value < next_value:
                value = -value
            total += value
        return total

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

Данная функция возвращает следующий элемент в итераторе. Она может работать со следующими видами итераторов:

объекты enumerate;
объекты zip;
возвращаемые значения функции reversed;
файлы
объекты csv.reader;
генератор-выражения;
генератор-функции;

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

Функции, которые когда-нибудь можно выучить

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

iter: возвращает итератор (список, набор и т. д.);
callable: возвращает True, если аргумент является вызываемым;
filter and map: вместо них рекомендуется использовать генератор-выражения;
Round: округляет число;
divmod: эта функция выполняет деление без остатка (//) и операцию по модулю (%) одновременно;
bin, oct и hex: служат для отображения чисел в виде строки в двоичной, восьмеричной или шестнадцатеричной форме;
abs: возвращает абсолютное значение числа (аргумент может быть целым или числом с плавающей запятой, если аргумент является комплексным числом, его величина возвращается);
hash;
object.

Прочие специфические функции

ord и chr: могут пригодиться при изучении ASCII или Unicode;
exec и eval: для исполнения строки;
compile;
slice: если вы реализуете __getitem__ для создания пользовательской последовательности, это может вам понадобиться;
bytes, bytearray и memoryview: если вы часто работаете с байтами;
ascii: похож на repr, но возвращает представление объекта только в ASCII;
frozenset: как set, но он неизменен (и хешируемый);
__import__: лучше использовать importlib;
format: вызывает метод __format__, который используется для форматирования строк;
pow: оператор возведения в степень (**);
complex: если вы не используете комплексные числа (4j + 3), она вам не понадобится.

Заключение

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

Использованы материалы: tproger.ru