# Голодный Питон 3

Алексей Владимирович Чесноков

Краткий справочник по языку Питон 3

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

Python -- красивый и местами загадочный язык. И даже зная его весьма неплохо, рано или поздно находишь для себя нечто такое, что раньше не использовал.

Среда

Официальный сайт Питона: http://python.org

Свежий дистрибутив можно скачать здесь:


http://www.python.org/ftp/python/3.8.1/python-3.8.1.exe


(Для XP: https://www.python.org/ftp/python/3.4.4/python-3.4.4.msi/ )

Другая бесплатная удобная среда разработки - Wing IDE 101

Её можно скачать отсюда:


https://wingware.com/pub/wing-101/7.2.1.0/wing-101-7.2.1.0.exe


Это чисто среда, т.е. требуется предварительная установка

Онлайн интерпретаторы (можно работать с телефона):


https://www.python.org/shell/


https://ideone.com/l/python-3


Среда разработки, идущая c дистрибутивом, называется: IDLE. У этой среды есть два окна Shell и Edit.


При запуске открывается окно Shell. Интерпретатор выполняет команды построчно: пишешь строку, нажимаешь Enter - интерпретатор выполняет ее, и наблюдаешь результат. В этом режиме можно использовать Питон как калькулятор.

Хотя Shell и позволяет перемещаться по ранее набранным строкам, вызвать на обработку можно только последнюю строчку. Получить ранее набранные строчки в Shell можно комбинацией Alt + p

Для программирования открываем окно Edit через меню File - New File. Запуск программы осуществляется через меню Run - Run Module либо F5. Если текст программы не сохранен, то среда предлагает сохранить его. Если программа зациклилась то остановить её можно комбинацией Ctrl + F6.

Для исполнения программы по шагам нужно включить режим debugger в Shell и после запуска жать на кнопку Over.

Элементы языка

Комментарии

Это что угодно, начинающееся на знак #

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

Директивы

Это не что угодно, начинающееся на знак #

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

# -*- coding: cp1251 -*- Windows

# -*- coding: cp866 -*- DOS

# -*- coding: UTF8 -*- UNIX


(-*- для красоты)


Операторы

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

Заметим, что все ключевые слова записываются маленькими буквами.

Операторы размещается каждый на отдельной строке.

Можно, разместить на одной строке несколько операторов через ';' но этого делать не стоит. Можно, также, разместить один оператор на нескольких строчках при помощи '\', но этого делать, также, не стоит.

Переменные (они же, объекты)

Идентификаторы (имена) переменных: Слова, начинающиеся с буквы. Размер играет роль. Ключевые слова употреблять нельзя.

Перечень ключевых слов (подчёркнуты ключевые слова, изучаемые тут):

'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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'

___________________________________________

Условные обозначения:

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

квадратными скобками красивого дизайна [ ] - необязательные конструкции.

После символа ? будем давать значение выражения.

Функции

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


имя_функции(параметр1, параметр2, ...)


У Питона большое количество встроенных функций. Кроме того, есть масса внешних модулей, и можно работать с функциями, содержащимися там.

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

Основные функции поставляются в комплекте с интерпретатором. Они называются встроенными. Это функции, доступные в Питоне "из коробки". Перечень их можно получить, нажав Ctrl+пробел. Появится перечень доступных функций. Выбрав нужную функцию, надо либо нажать на открывающую скобку, либо на Enter.

Помимо встроенных, есть множество функций в составе модулей. Перечень модулей можно получить набрав в Shell - help('modules')

Подключение модуля: import имя_модуля

Модуль math - наиважнейший для нас в Питоне. Этот модуль даёт функционал работы с числами (синусы, факториалы, корни, константы и т.п.).

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

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


math.cos(math.pi/2)


math.cos() - это функция синуса, math.pi - это число ?


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

Методы

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


имя_объекта.имя_метода(параметр1, параметр2, ...)


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

Переменные

Создание переменных осуществляется через присваивание. Тип определяется типом выражения. Одна и та же переменная в разных местах может иметь разные типы. Символ оператора присваивания - "=".


имя_переменной = выражение


Удаление переменной производится оператором del имя_переменной

Примеры:

Целое число (int) a=50

Вещественное число (float) a=50. a=5e2

Строка (str) a="Hello, Python!" a='Hello, Python!'

Список (list) a=[1, 2., "mir", 'trud']

Кортеж (tuple) a=(1, 2., "mir", 'trud')

Мы ограничимся этими типами, хотя их перечень этим отнюдь не исчерпывается.

Можно нескольким переменным, так сказать, паровозиком, присвоить одно и то же значение (кроме списка):

A=b=c=d=qqmaria=99

и, все пять переменных станут равны 99.

Можно присвоить сразу список переменных.

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

Переменным присваиваются либо значения, либо буквы строки.


Примеры:

x, y = 1, 3 ? значение x станет 1, значение y станет 3

x, y = "АБ" ? значение x станет "А", значение y станет "Б"

Количество элементов слева и справа должно совпадать.

Логические переменные True и False эквивалентны числам 1 и 0, их можно использовать в качестве этих чисел. А числовые выражения можно использовать в качестве логических - если оно равно 0, то это False, если не равно 0, то True.

Числа

Вещественные числа пишут с точкой, "научная" запись - с буквой "e". К примеру, число Авогадро = 6,02·1023 записывается так: 6.02e23

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

0b11101 двоичная

0x1D шестнадцатеричная

0о35 восьмеричная

Основные операции для чисел:

A + B - сумма; A - B - разность;

A * B - произведение; A / B - частное;

A ** B - возведение в степень. A // B - целая часть от частного;

A % B - остаток от деления A на B

Если операнды целые, то и результат целый. Если хоть один из операндов вещественный, то и результат вещественный. Исключения - деление двух целых чисел и возведение в отрицательную степень.

Целые (но не вещественные) числа поддерживают длинную арифметику:

3 ** 100 = 515377520732011331036461129765621272702107522001

Полезно помнить, что квадратный корень числа x - это x ** 0.5, а корень n-ой степени это x ** (1 / n).

А что касается A ^ B , то это - побитовое "исключающее или". Не перепутайте!

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

Правила определения приоритетов операций следующие:

-- Возведение в степень справа налево, то есть 3**3**3 это 327 а не 273.

-- Унарный минус (перемена знака):

Если унарные операторы слева от операции **, то возведение в степень имеет больший приоритет, а если справа - то меньший


-2**-2 это -(2 ** (-2)), т.е. -0,25


-- Умножение, деление, остаток от деления - слева направо.

-- Сложение и вычитание - слева направо.

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

round(X [, N]) - Округление до N знаков после запятой.

abs(x) - Абсолютная величина (модуль числа).

bin(x), oct(х), hex(х) - Преобразование целого числа в двоичную (восьмеричную, шестнадцатеричную) строку.


Строки

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

Основные операции над строками:

A + B -- конкатенация (слипание) двух строк;

A * N -- дублирование строки N раз (N должно быть целое).

'ма'+'ма' ? мама 'ма'*2 ? мама

Возможны разные комбинации этих операций со скобками. Например:

2*(' '+'бар'*2+'ис')+ 'ович' ? барбарис барбарисович

Логические операции:

in - с её помощью можно определить, есть ли подстрока в строке,

not in (из двух слов) - отсутствует ли подстрока в строке.

'Мама' in 'Съешь этих мягких французских булок' ? False

'француз' in 'Съешь этих мягких французских булок' ? True

Подстрока, которая обычно, в документации обозначается термином "Срез (slice)"

Пусть s это - строка, равная

s="АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"


Срез


Значение


s[:]

АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ

s[0]

А

s[1]

Б

s[-1]

Я

s[:5]

АБВГД

s[-3:]

ЭЮЯ

s[3:8]

ГДЕЁЖ

s[14:16]+s[-15]

НОС

Пояснение:

s[n:m:k] - это подстрока строки s, начиная с символа n, до символа,

предшествующего m с шагом k.

Внимание! Верхняя граница диапазона индексов не включительная!

Символы считаются от нуля.

Если ":" отсутствует, то срез - это один символ,

Если n отсутствует, то срез начинается с начала строки,

Если m отсутствует, то срез продолжается до конца строки,

Если n или m отрицательные, то счет идёт от конца строки.

Если k отсутствует, то шаг равняется единице.

Если k отрицательное, то подстрока разворачивается.


Важные встроенные функции строк.

s=str(x) - преобразует любое число в строку

k=len(s) - вычисляет длину строки

s=chr(x) - выдаёт один символ, код ASCII которого равен x.

x=ord(s) - выдаёт код ASCII одного символа

Важные методы строковой переменной:

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


s.count(str, [start],[end]) - Вычисляет количество str в строке.

s.find(str, [start],[end]) - Поиск str в строке. Вычисляет позицию первого вхождения. Если такого нет, то выдаёт -1

s.rfind(str, [start],[end]) - Поиск str в строке c конца. Вычисляет позицию последнего вхождения. Если такого нет, то выдаёт -1

s.replace(str1, str2) - Выдаёт строку, в которой заменяет str1 на str2

s.upper() - Выдаёт строку, преобразованную к верхнему регистру

s.lower() - Выдаёт строку, преобразованную к нижнему регистру

s.strip() - Выдаёт строку, в которой удаляет пробелы, символы табуляции, возвраты каретки и переводы строк вначале и в конце

s.isdigit() - Определяет, состоит ли строка из цифр


В Питоне строковые переменные неизменны, - их нельзя изменить; можно только этой переменной присвоить вновь сформированную строку.

Например, надо исправить одну букву:

s="Энциклопудия"

если написать s[8]= "е" то будет ошибка.

Приходится писать так:

s=s[:8]+"е"+s[9:]

s ? "Энциклопедия"

Списки

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

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

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

Необязательность скобок кортежа таит определенную опасность. К примеру:

d=2.5 ? 2,5 (это числовая переменная, равная двум с половиною)

d=2,5 ? (2, 5) (это кортеж, состоящий из двух значений - два и пять)


Элементы списка (кортежа) не обязательно должны быть одного типа.

Как и для строк, нумерация индексов начинается с нуля.

В отличие от строк, элементы списка (но не кортежа) изменяемы.

Основные операции над списками:

A + B -- слияние двух списков;

A * N -- дублирование списка N раз (N должно быть целое).

Опять, таки, возможны разные комбинации этих операций со скобками.

Например

a=3*([6]*2+[4]) ? [6, 6, 4, 6, 6, 4, 6, 6, 4]

a=(55,+5)*8

это не 480.0, а вовсе даже ? (55, 5, 55, 5, 55, 5, 55, 5, 55, 5, 55, 5, 55, 5, 55, 5)

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

В списке, поддиапазон можно удалить оператором del:

a=[0, 1, 2, 3, 4, 5, 6, 7, 8]

del a[3:5] ? [0, 1, 2, 5, 6, 7, 8]

Логическая операция in, при помощи которой можно определить, есть ли элемент в списке, тоже работает: 33 in a ? False

При помощи среза осуществляется создание копии списка.

L1 = L2[:] - создание копии списка.

Важно! Если мы запишем вот так: L1 = L2 то произойдет создание второй ссылки на список, а не копии этого списка. Другими словами, будет один список с двумя именами, а не две копии. Все, что мы будем делать с элементами списка L1, будет происходить и с элементами списка L2. И наоборот. Кстати, именно поэтому, списки паровозиком не присваивают. С кортежами такой фантасмагории не происходит.

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

Пусть L - какой-нибудь список.

len (L) - получение количества элементов списка.

max(L), min(L) - получение максимального, минимального значения

sum(L) - получение суммы списка

map(func, L) - получение нового списка из заданного путем применения к

каждому элементу этого списка некоторой функции func.

sorted(L) - получение отсортированного списка


Следующие функции относятся к так называемым функциям-итераторам. Используются только в операторе for (см. ниже). Результатом их деятельности является:

set(L) - "контейнер", содержащий не повторяющиеся неупорядоченные элементы списка. Называется эта штука - "множество"

reversed(L) - список в обратном порядке

enumerate(L) индекс очередного элемента списка и его значение

range([start,] N, [step]) - числа арифметической прогрессии, начиная со start, заканчивая N-1 с шагом step. Если start отсутствует, то начиная с 0. Если step отсутствует, то шаг равен единице. Если step отрицателен, то start должен быть больше N. Если step присутствует, то start обязан быть.


Примеры:

range(9) ? [0, 1, 2, 3, 4, 5, 6, 7, 8]

range(3,9) ? [3, 4, 5, 6, 7, 8]

range(3,9,2) ? [3, 5, 7]

range(9,0,-1) ? [9, 8, 7, 6, 5, 4, 3, 2, 1]

Важные методы списков:

Методы списков (кроме index и count) ничего не выдают, но, изменяют сам список. Потому присваивание, хотя ошибкой и не является, но бесполезно.

L.append(x) - Добавляет элемент x в конец списка

L.extend(M) - Добавляет элементы последовательности M в конец списка L

L.insert(i, x) - Вставляет перед i-ым элементом значение x

L.remove(x) - Удаляет первый попавшийся элемент, равный x

L.sort() - Сортирует список по возрастанию

L.reverse()- Разворачивает список

L.index(x, [N [, K]]) - Находит позицию элемента x между N и K.

L.count(x) - Вычисляет количество элементов со значением x

Будьте аккуратны с методами index и remove. Если в списке значения x не случится, то возникнет ошибка. Неплохо, перед использованием этих методов, проверить наличие значения x, например, операцией in.

У кортежей из методов есть только index и count.

Элементы списков, подвергаемых сортировке должны иметь один тип.


Примеры работы со списком:

Действие

Код

Результат

формируем список из одного элемента

a = [7]

а ? [7]

добавляем к нему элемент 5

a.append(5)

а ? [7, 5]

добавляем к нему элемент 6

a = a + [6]

а ? [7, 5, 6]

формируем список из трех элементов

b = [1, 2, 3]

b ? [1, 2, 3]

формируем список из трех элементов

d = 3*[0]

d ? [0, 0, 0]

объединяем списки a и b

c = a + b

c ? [7, 5, 6, 1, 2, 3]

выведем первый элемент

print (c[0])

выведен 7 - первый элемент

выведем последний элемент списка

print (c[-1])

выведен 3

меняем значение элемента с индексом один на 8

c[1]=8

с ? [7, 8, 5, 1, 2, 3]

удалим элемент списка, который равен 2

c.remove(2)

с ? [7, 8, 5, 1, 3]

удалим элемент списка с индексом два

del c[2]

c ? [7, 8, 1, 3]

Методы списков - меняют список, функции - не меняют. Следовательно, если надо отсортировать список, то применяется метод L.sort(), а если нужен отсортированный список, то функция - sorted(L).

Кортеж, по сути - неизменяемый список. Зачем же нужны кортежи, если есть списки? Защита информации от дурака!

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


Примеры:

x, y, z = 1, 3,7 ? x станет 1, y станет 3, а z - 7

x, y, z = "МИР" ? x станет "М", y станет "И", а z - "Р"


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

Функция int преобразует в целое число:

-- любое число

-- строку, изображающую целое число

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

Пример:

int(12.4) ? 12 int("12") ? 12 int("12", 4) ? 6

Функция float преобразует в число с плавающей точкой любое число или строку, изображающую любое число.

Функция str преобразует что угодно в строку.

Функция tuple преобразует список или строку в кортеж.

Функция list преобразует строку в список букв.

list("Python") ? [ "P","y","t","h","o","n" ]

Метод split формирует список из строки по разделителю:

L=s.split(разделитель)

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

Обратное преобразование выглядит крайне загадочно:

s=разделитель.join(L)

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

Пример:

s= "Python 3.X.X"

list(s) ? ['P', 'y', 't', 'h', 'o', 'n', ' ', '3', '.', ' X ', '.', 'X']

s.split() ? ['Python', '3. X.X']

s.split(".") ? ['Python 3', 'X', 'X']

"-".join(["A","B","C"]) ? 'A-B-C'

Логические выражения и логический тип данных

Логические константы: True и False (редкий случай записи служебных слов не только маленькими буквами)

Операции сравнения:

=?= Равны ли оба операнда?

!= Различны ли оба операнда?

< (>) Меньше (больше) ли слева чем справа?

<= (>=) Меньше или равно (больше или равно) ли слева и справа?

Логические операции:

not - не, and - и, or - или.

О логической операции in мы уже говорили.

Приоритеты: Операции сравнения выполняться после арифметических операций, Логические операции - самые последние, в следующем порядке: in, not, and, or.

Хорошая новость: если выражение слева от операций and или or однозначно определяет результат этой операции, то выражение справа уже не вычисляется (т.е., допустимо выражение, if x!=0 and 100/x>5:) .

True и False эквивалентны числам 1 и 0, их можно использовать в качестве этих чисел. А числовые выражения можно использовать в качестве логических - если оно равно 0, то это False, если не равно 0, то True.


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

x | y - побитовое или, x ^ y - побитовое исключающее или,

x & y - побитовое и, ~x - инверсия битов.

Не перепутайте их с логическими операциями!

.

Условный оператор

Об операторных скобках

В Питоне, равно как и в других языках, операторы цикла, условные операторы, подпрограммы состоят из двух частей: заголовка оператора и тела оператора, которое состоит из программного кода, заключенного в операторные скобки. В качестве операторных скобок в Питоне служат отступы, которые можно формировать пробелами либо табуляцией. Главное, - одинаково. Следовательно, текст программы на Питоне нужно писать, аккуратно отображая уровни вложенности отступами. Тело оператора обязательно. Если нам оно не нужно, то используется пустой оператор pass. Если тело - один оператор, то его можно писать сразу после двоеточия


Пример:

if x>1:

a=4

b=7

с=8

elif x==1:

a=5

b=2

с=1

elif x==0:

a=11

b=12

с=13

else:

a=8

b=9

с=3


Sapienti sat... (и не забываем про двоеточия!)

Условие if должно быть одно, и стоять вначале условного оператора.

Условий elif может быть несколько, а может и не быть ни одного.

Условие else может и не быть, но если оно есть, то оно одно, и должно стоять в конце условного оператора.

Оператор в теле, хотя бы один, быть обязан. Но, если, ну совсем, нет операторов, то употребляется пустой оператор pass

Оператор Цикла

В Питоне есть два оператора цикла: while и for.

Есть операторы, которые меняют нормальный ход цикла for или while:

Оператор continue начинает следующий цикл, минуя оставшееся тело.

Оператор break досрочно прерывает цикл.

(естественно, их надо употреблять в компании с условным оператором!)

Цикл while

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

a=3

while a<100:

a=a+22


Цикла с постусловием (важным, когда мы, например, реализуем ввод и обработку данных в цикле) в Питоне нет, но он конструируется искусственным образом, например так:


while True:

a=int(input())

if a==0: break

операторы, использующие a

Цикл for

Цикл for в Питоне перебирает значения из последовательности, в качестве которой может быть строка, список, кортеж, файл, функция range. Эти значения (но не индекс!) последовательно присваиваются переменной.

for переменная in последовательность:

тело цикла

Переменной присваивается значение:

-- очередной буквы, в случае строки

-- очередного значения, в случае списка, кортежа

-- очередной строки, в случае файла,

-- очередного номера, в случае функции range

Согласно синтаксиса языка, цикла со счетчиком в Питоне нет.

Имитация заголовка цикла for, аналогичного циклу for в других языках:

for i in range(1, N+1, k):

что соответствует следующей строке Basic: FOR i=1 TO N STEP k

Заметим, что for i in range(N+1): эквивалентен оператору Basic FOR i=0 TO N


Перебор элементов (для ради посмотреть) последовательности (списка, кортежа, строки, файла, функции range) производится так:

простая итерация: (перебор значений L подряд)

for x in L:

сортированная итерация: (перебор отсортированных значений L)

for x in sorted(L):

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

for x in set(L):

обратная итерация: (перебор значений L подряд в обратном порядке. В случае файла не работает)

for x in reversed(L):

Внимание! "x" - это переменная, которой присваивается значение очередного элемента списка, а не сам элемент. Никакое изменение x на сам список не влияет. Если охота поменять значения элементов списка, то цикл надо делать не по элементам, а по индексам переменных, например:

for i in range(len(L)):

L[i]=...

Другое решение - использование функции enumerate

for i, x in enumerate(L):

L[i]=...


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

Ввод-вывод

Для вывода на экран используется слово print. В третьем питоне print - это функция, - что мы хотим вывести, записывается в скобках через запятую. Кроме того, у неё есть параметры. Например, end = ''", и следующий print выводится на той же строке.

Для ввода данных с клавиатуры используется функция input(["сообщение"]). Поскольку это - функция, а не оператор, то она выдает одно значение, которое введёт пользователь. А это значит, что надо озаботиться тем, чтобы это значение стало быть присвоено какой-нибудь переменной. Примерно так:


x=input()


Работа программы остановится, пока пользователь не введет запрашиваемое. Чтобы пользователь понял, что от него хотят, функция input() имеет необязательный аргумент -- сообщение, это сообщение появиться на экране и проинформирует человека о смысле запрашиваемого.


x=input("Введите слово)


В третьем питоне функция input() выдает строку, которое ввел пользователь. Для того, чтобы получилось число, надо эту строку преобразовать в число с помощью функций int() или float().


x=int(input("Введите x))


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

x,y=map(int, input("Введите x и y через пробел ").split())


Но это работает только для крайне аккуратного пользователя. Иначе он получает:

ValueError: need more than 1 value to unpack - если введёт одно число

ValueError: too many values to unpack - если введёт три числа

ValueError: invalid literal for int() with base 10: - если будет два числа, но через запятую


Разоблачение магии:

функция input("Введите x и y через пробел ")

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

метод .split()

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

функция map(int, ...

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

x,y=

...кортежу (с опущенными скобками) из двух переменных присваиваются значения этого получившегося списка, и, таким образом, в x оказывается первое значение, а в y - второе...

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

Файловый ввод-вывод

Предварительные замечания:

-- Файлы открываются в текстовом режиме - это значит, что чтение из файла и запись в файл строки происходит в определённой кодировке (она зависит от платформы).

-- В файлах присутствует перевод строки, кодируемый парой байтов 0xD 0xA. Эта сладкая парочка в Питоне обозначается "\n". Питон читает строки вместе с символом перевода строк "\n". От него можно избавиться, например, с помощью метода strip("\n") (а метод strip() заодно удаляет и обрамляющие пробелы) . Питон пишет строки без символа "\n". Его надо добавлять сугубо, вставляя в нужные места "\n".

-- В указании пути к файлу следует использовать удвоенный обратный слеш "\\" или одинарный прямой слеш "/".

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

for s in open('c:\\7.txt'):

print (s.strip("\n"))

Чтобы записать строку в файл:

open('c:\\7.txt','w').write("строка"+"\n")

Чтобы добавить строку к содержимому файла:

open('c:\\7.txt','a').write("строка"+"\n")


Работа с файлами "по взрослому" выглядит так: имеется функция open() результатом которой является объект типа файл.

open (имя_файла, режим)

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

Второй аргумент - символ, символизирующий процесс обмена:

'r' - файл открыт для чтения,

'w' - файл открыт для записи,

'a' - файл открыт для добавления.

Если аргумент режим опущен - считается, что он равен 'r'.

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


Вот мы открыли файл c:\t.txt для чтения:

f = open("c:\\t.txt",'r')

f.read([N]) - этот метод читает всё содержимое файла и выдает его в виде одной строки. Если размер файла по величине окажется во много раз больше оперативной памяти компьютера, то это уже будет личная трагедия программиста. Для предотвращения сего есть параметр N, который определяет количество байт, которое будет прочитано за раз.

f.readline() - этот метод употребляют, обычно, в цикле while - он читает очередную строку из файла, и, если приходит пустая строка, то, значит, достигнут реальный конец файла, в то время как, незаполненная строка, представленная посредством символа перевода строк '\n', непуста.

f.readlines([N]) - этот метод выдает список всех строк, находящихся в файле. Если есть параметр N, то метод читает из файла указанное количество байт, плюс еще некоторое количество байт для завершения строки, и формирует список строк.

Не забываем закрывать файл методом f.close()


f = open("c:\\t.txt",'w')

Это мы открыли файл c:\t.txt для записи.

Следующие методы осуществляет запись в файл:

f.write(строка) записывает содержимое одной строки в файл. Несколько строк одним методом write, подобно print, вывести никак не получится. В Python 3.x этот метод выдает количество записанных байтов. Заметим, что если мы вызовем метод write несколько раз, то в файле между записанными строчками перевода строк не будет. Если мы желаем делать переводы, то должны об этом позаботится сугубо, выводя в нужные места символ "\n".

f.writelines(список строк) записывает список строк в файл (без "\n").

Не забываем закрывать файл методом f.close()

Свои собственные функции

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

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

Тело функции определяются операторными скобками, т.е. отступами.

Значение функции и её тип определяется оператором return: то значение, которое указанно в этом операторе, и является значением функции. Если оператора return нет, то функция выдаст специальное значение - None -тогда функция становится тем, что в других языках именуют подпрограммой или процедурой. Оператор return обычно помещают в конце текста функции, так как Питон, встретив return, тут же покинет функцию.

Обычный синтаксис собственной функции:

def Имя_функции ([[форм_параметр_1], форм_параметр_2,] ...):

текст функции

[return какое-нибудь_значение]

Вызов собственной функции:

x= Имя_функции ([[факт_параметр_1], факт_параметр_2,] ...)

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

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

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

Описание (инициация) таблицы:

Если массив маленький, то можно делать прямое присваивание:

a = [[1, 2, 3], [4, 5, 6]]

Инициация же большой двумерной таблицы имеет особенности.

Пусть охота создать список, размером nвm, заполненный нулями. Очевидное решение a = [[0] * m] * n оказывается неверным, по причине, которая выходит за рамки нашего разумения. Воспримем это как данность.

Вот решения, которые работают:

1 способ (наглядный)

a = []

for r in range(n):       # цикл для n строк

a.append([])          # в каждой создаем пустую строку (a=[[]])

for c in range(m): # цикл в каждой строке для - m элементов

a[r].append(0)  # добавляем элементы в строке (a= [[0, 0,...]])

(причем, добавлять можно только через метод append, а через операцию слияния, типа a[r]= a[r]+ [0] добавлять нельзя!)

2 способ (ненаглядный)

a = []

for i in range(n):

a.append([0] * m)

3 способ (заклинание)

a = [ [0] * m for i in range(n)]


Вывод таблицы:

for r in a:

print (r)

Использование таблицы:

Пусть А - это список списков (таблица), тогда:

А[2] - это третья строка таблицы, а

А[2] [2] - это третий элемент третьей строки таблицы (помним, что все индексы начинаются от 0).

Важные различия Python 2.7.x и Python 3.x


Python 2.7.x


Python 3.x


Вывод на

экран:

оператор print


print "мама мыла раму"


функция print


print ("мама мыла раму")


Ввод с

клавиатуры

функция input() дает число,

функция raw_input() строку

функция input() дает строку,

для ввода числа вводим строчку и преобразуем в число, т.е.


int(input())


Деление двух целых чисел

Результат - целое число


3/4 = 0


Результат - действительное число


3/4 = 0,75


Русские буквы в тексте программы

кодировка CP1251

("мама мыла раму" во всех смотрелках России)

кодировка UTF 8

("Р?Р°Р?Р° Р?С?Р"Р° С?Р°Р?С?" в некоторых смотрелках России)

Способ создания списка целых чисел

range() - создает весь список (итератор), может использоваться как в операторе for, так и самостоятельно

range() - генератор, используется только в операторе for. (генерирует только очередное значение)

Операция сравнения

"не равно"


!= или <>


только !=


Восьмеричные числа


0720


0o720


Функции работы с файлом


open или file


только open


Однако


-- Если в программе на Python 2.7.x употребить заклинание:

from __future__ import division

(до и после future по два подчёрка) то результатом деления целых чисел будет действительное число, как в Python 3.x.

-- Если в программе на Python 2.7.x употребить заклинание:

from __future__ import print_function

(до и после future по два подчёрка) то print станет функцией, как в Python 3.x.

-- Если в программе на Python 3.x. вначале употребить директиву:

# coding: cp1251

то кодировкой русских букв тексте программы будет кодировка CP1251

Nota Bene!


-- Если мы запустили программу, то окно Shell автоматически становится активным. И, когда программа завершится, то мы так в Shell и останемся. Значит, чтобы запустить программу еще раз, надо перейти в окно с программой (Edit), и только там нажимать F5.

-- Если программа зациклилась, то остановить её можно Ctrl + F6 , либо Ctrl + С .

-- Все служебные слова пишутся маленькими буквами. Идентификаторы - только латинскими буквами. Размер играет роль, так что, для единообразия, лучше их тоже писать тоже маленькими буквами.

-- Возведения в степень выполняются справа налево, то есть 3**3**3 это 327 а не 273, следовательно, надо употреблять скобки, чтобы не запутаться

-- Если число с минусом возводить в степень, то минус остается за кадром, то есть

-2**2 это -4, и, следовательно, надо употреблять скобки, чтобы не запутаться: (-2)**2 это 4

-- A ^ B - это НЕ возведение в степень, а совершенно другая операция (побитовое исключающее или) .

-- При использовании print необходимо ставить скобки

-- Функция input выдаёт строку а не число.

-- Нумерация элементов в строке, списке, кортеже начинается с 0.

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

-- Методы строки не меняют строку. Методы списка меняют список.

-- В заголовках операторов if, elif, else, while, for, def не забывайте про двоеточия.

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

-- В операции сравнения "==" - два знака = подряд.

-- Есть битовые операции: | - побитовое или, ^ - побитовое исключающее или, & побитовое и, ~ инверсия, но использовать их стоит (кто понимает) только для битовых операций, но не для логических операций.

-- Согласно синтаксису языка, цикла со счетчиком в Питоне нет, а цикл for совсем не то, что считается циклом for в других языках.

-- В цикле for x in L изменение x не влияет на L

-- d=2,5 это не число, равное 2,5, а кортеж, состоящий из 2 и 5.

-- При работе с путями файлов следует использовать либо удвоенный обратный слеш "\\" либо одинарный прямой слеш "/".

-- При чтении из файла необходимо избавляться от символа перевода строки "\n" при помощи метода strip("\n")

-- При записи в файл чисел их необходимо преобразовать в строку.

-- При записи в файл к строкам необходимо добавлять символ перевода "\n"


Источники информации:

http://pythontutor.ru

http://pythonworld.ru

https://docs.python.org/3/

https://ru.wikibooks.org/wiki/Python

http://itnote.ru/2011/05/25/python-file

http://pythonicway.com/python-functions

http://www.iakovlev.org/index.html?p=5791

http://wombat.org.ua/AByteOfPython/toc.html

http://bit126.moy.su/load/programm/python/72

http://radio-hobby.org/modules/instruction/python

http://www.script-coding.com/Python/Otkidach2.html

http://gorodovets.blogspot.ru/2013/07/python_27.html

http://toly-blog.ru/programming/python-recepty-massivy

http://www.py-my.ru/post/4bfb3c691d41c846bc000050#!

http://santysoft.narod.ru/articles/art_momentary_python.html

http://www.russianlutheran.org/python/idle_doc/using_idle.html

http://younglinux.info/sites/default/files/python_structured_programming.pdf

Содержание


http://ailen.eklablog.com


21


Петербург


08.04.2020


Условие, x>1 при котором ...

} Выполняются эти операторы

В противном случае, но при выполнении условия x=1 ...

} Выполняются эти операторы

В противном случае, но при выполнении условия x=0...

} Выполняются эти операторы

И в самом противном случае, если не выполнено всё предыдущее...

} Выполняются эти операторы