В языке python как и в математике

Операторы, типы данных и переменные¶

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

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

Переменные: место, где мы храним данные¶

В предыдущем уроке, мы использовали переменную name для записи в неё имени «Вася». Теперь давайте посмотрим, что такое в действительности переменные и как они работают.

Переменная¶

Переменная — это нечто такое, что нужно запомнить вашему ком-ьютеру на время работы программы.

Когда Python «запоминает» что-либо, он сохраняет эту информацию в памяти компьютера. Python может запоминать значения нескольких типов данных, например числовые значения (такие как 7, 42 или даже дробные числа, вроде 3.1415) и строки (буквы, символы, слова, предложения — все, что вы можете набрать на клавиатуре). А также и пользовательские типы данных, но это уже забегая далеко вперёд.

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

Например, в примере с именем «Вася» мы сделали это вот так:

Если мы присваиваем строку, то нужно не забыть взять её в кавычки ( "" )!

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

Если это число, то кавычки ( "" ) не нужны. Если мы возмём в кавычки, например "3.1415" , то это уже будет не число, а строка!

Как Python различает типы данных?

Python — язык с динамичекой типизацией. Это означает, что он может сам, то есть без указания программиста, динамически адаптировать те или иные переменные к нужному типу данных. То есть, например, если мы сначала запишем в переменную число var = 42 , то ничто нам не помешает потом записать в неё строку var = "Hello" — Python всё сделает!

Имена переменных¶

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

Как правило, переменные называются простыми именами, описывающими содержащееся в переменной значение (как в случае с переменной name , хранящей имя).

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

1. Используевые буквы должны быть латинскими.
2. Остальные символы в имени переменной должны быть буквами, цифрами или нижним подчеркиванием («_«). Внутри имени переменной пробелы не допускаются (например, имя my name приведет к появлению сообщения о синтаксической ошибке, так как Python подумает, что вы перечислили две пе ременные и разделили их пробелом).
3. Имена переменных в Python чувствительны к регистру (БОЛЬШИЕ или маленькие буквы). Это значит, что если в имени переменной мы использовали только буквы нижнего регистра (например, abc ), то воспользоваться значением, сохраненном в переменной, мы можем, только указав имя переменной в точно таком же виде, в том же регистре. Таким образом, переменная My_Name отличается от my_name , а MY_NAME от них обеих.

Использование переменных¶

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

Например, как в программе приветствия Васи.

print("Привет", name) — здесь мы ввели строку "Привет" вместе с тем, что хранилось в name .

Чтобы лучше понять этот механизм — запусти интерпретатор Python и попробуй создать свои переменные и взять из них значения.

Пользовательский ввод¶

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

Выглядеть это будет так:

name = input("Введите своё имя: ") — создаём переменную name и записываем в неё результат выполнения команды (функции) input , а в скобочках к команде () передаём то, какую строку вывести в консоль при запросе.

print("Привет", name) — вывести в консоль «Привет» вместе с name , вставив между ними пробел.

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

Числа и математика¶

Компьютеры очень хороши в математических операциях (сложение, вычитание и так далее). Ваш компьютер способен совершать более одного миллиарда (1’000’000’000, или тысячи миллионов) математических операций в секунду!

Язык Python дает нам доступ к этому мощному ресурсу математических вычислений, предоставляя для этого числа двух основных видов:

• Целые числа. Например, 1, 2, 42, 1234 и тд.
• Вещественные (дробные) числа. Например, 1.5, 3.1415, 2.67842356 и тд. Их ещё называют числа с плавающей точкой

Но чтобы от чисел было больше пользы, мы должны уметь ими совершать с ними операции. И здесь Python предоставляет нам множество возможностей!

Операторы¶

Оператор — это символ, или несколько символов — в отличие от имени переменной или функции (команды). Например, «+» умеет брать два числа слева и справа от себя(они называются операнды), складывать и подставлять вместо себя и операндов то, что получается.

Математические символы, такие как + (плюс) и − (минус), являются операторами, так как они оперируют (или выполняют вычисления) числами в уравнении. Когда мы говорим вслух «4 + 2», чтобы ввести это на калькуляторе, мы хотим сложить числа 4 и 2, чтобы получить их сумму, 6.

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

Задания¶

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

Processing¶

1. Напиши код, который объяснит Processing, как нарисовать дом с крышей, окном и дверью. Можешь добавить больше деталей: печную трубу, траву, облака — выбор не ограничен. Не забудь раскрасить! Чтобы было легче позиционировать объекты, используй переменные и операторы.
2. По желанию, можешь попробовать изобразить более сложные или перейти к другим заданиям.

Стандартный Python¶

Чепуха¶

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

Результат работы программы должен выглядеть примерно следующим образом:

Попробуй придумать ещё что-нибудь забавное 😉

И не забудь сохранить свою программу!

Новая чепуха!¶

Давайте сделаем нашу игру чуть более интересной.

1. Создай новый файл для кода, сохрани под тем именем, которое тебе больше понравится.
2. Добавьте строку, которая бы запрашивала ввод названия животного с предлогом «на».
3. Затем измени команду print() , убрав слово собаку и добавив переменную animal после предложения, взятого в кавычки (не забудь в команде print() добавить запятую перед новой переменной).

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

И не забудь сохранить свою программу!

Пиццерия¶

Давайте представим, что мы не только программисты, но и владельцы нашей собственной пиццерии.

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

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

1. Спросить человека, сколько пицц он желает заказать.
2. Запросить стоимость каждой пиццы, указанную в меню.
3. Подсчитать стоимость каждой пиццы как подытог.
4. Подсчитать начисляемый налог с продаж по ставке 8 процентов от подытога.
5. Добавить сумму налога с продаж к подытогу и получить итоговую стоимость.
6. Показать пользователю общую сумму к оплате, в том числе налог.

Рефлексия¶

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

Арифметические операции — Основы Python

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

Например, для сложения двух чисел в математике мы пишем: 3 + 4 . В программировании — то же самое. Вот программа, которая складывает два числа:

Арифметика в программировании практически не отличается от школьной арифметики.

Строчка кода 3 + 4 заставит интерпретатор сложить числа и узнать результат. Эта программа будет работать, но в ней нет смысла. По сути, мы не даем команду интерпретатору, мы просто говорим ему: «Смотри, сумма трех и четырех». В реальной работе недостаточно сообщать интерпретатору о математическом выражении.

Например, если создавать интернет-магазин, недостаточно просить интерпретатор посчитать стоимость товаров в корзине. Нужно просить посчитать стоимость И показать цену покупателю.

Нам нужно попросить интерпретатор сложить 3 + 4 И дать команду сделать что-то с результатом. Например, вывести его на экран:

Кроме сложения, доступны следующие операции:

• — — вычитание
• * — умножение
• ** — возведение в степень
• / — деление
• // — целочисленное деление
• % — остаток от деления

Теперь выведем на экран результат деления, а потом результат возведения в степень:

Разберем, как в программировании называются составляющие математических операций.

Операторы и операнды

Знак операции, такой как + , называют оператором. Операторы выполняют операции над определенными значениями, которые называются операндами. Сами операторы — это обычно один или несколько символов. Реже — слово. Подавляющее большинство операторов соответствуют математическим операциям.

В этом примере + — это оператор, а числа 8 и 2 — это операнды.

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

Операции бывают не только бинарными, но и унарными — с одним операндом, и тернарными — с тремя операндами. Причем операторы могут выглядеть одинаково, но обозначать разные операции. Символы + и — используются не только как операторы. Когда речь идет про отрицательные числа, то знак минуса становится частью числа:

Выше пример применения унарной операции к числу 3 . Оператор минус перед тройкой говорит интерпретатору взять число 3 и найти противоположное, то есть -3 . Это может сбить с толку, потому что -3 — это одновременно и число само по себе, и оператор с операндом. Но у языков программирования такая структура.

Коммутативная операция

«От перемены мест слагаемых сумма не меняется» — это один из базовых законов арифметики, который также называется коммутативным законом. Бинарная операция считается коммутативной, если вы получаете тот же самый результат, поменяв местами операнды. В этом случае сложение — это коммутативная операция: 3 + 2 = 2 + 3 .

Но вычитание — это не коммутативная операция: 2 — 3 ≠ 3 — 2 . В программировании этот закон работает точно так же, как в арифметике. Более того, большинство операций, с которыми мы сталкиваемся в реальной жизни, не являются коммутативными. Отсюда вывод: всегда обращайте внимание на порядок того, с чем работаете.

Композиция операций

Операции можно соединять друг с другом и вычислять все более сложные составные выражения. Чтобы представить, как происходят вычисления внутри интерпретатора, разберем пример: 2 * 4 * 5 * 10 .

1. Сначала вычисляется 2 * 4 и получается выражение 8 * 5 * 10
2. Затем 8 * 5 . В итоге имеем 40 * 10
3. В итоге происходит последнее умножение, и получается результат 400

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

Приоритет операций

Представим, что нужно вычислить такое выражение: 2 + 2 * 2 . Именно так и запишем:

В школьной математике есть понятие «приоритет операции». Приоритет определяет, в какой последовательности должны выполняться операции. Умножение и деление имеют больший приоритет, чем сложение и вычитание, а приоритет возведения в степень выше всех остальных арифметических операций. Например: 2 ** 3 * 2 вычислится в 16 .

Но нередко вычисления должны происходить в порядке, отличном от стандартного приоритета. Тогда приоритет нужно задавать круглыми скобками. Так было и в школе, например: (2 + 2) * 2 . В скобки можно заключать любую операцию. Они могут вкладываться друг в друга сколько угодно раз. Вот примеры:

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

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

Важно запомнить: код пишется для людей. Код будут читать люди, а машины будут только исполнять его. Для машин код — корректный или некорректный. Для них нет «более» понятного или «менее» понятного кода.

Операторы в Python от А до Я

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

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

Немного терминологии

Python является язык общего назначения. Он включает в себя принципы объектно-ориентированного программирования. Поэтому перед тем, как изучать операторы и их нюансы, стоит запомнить несколько ключевых терминов. Без них создать качественное приложение не представляется возможным:

1. Алгоритм – своеобразный набор правил и инструкций. Он необходим для обработки функций и выполнения тех или иных задач.
2. API – интерфейс прикладного программирования. Включает в себя структурные данные, протоколы и правила, позволяющие быстро разрабатывать ПО, а также налаживать его взаимодействие с разного рода службами.
3. Переменные – именованные ячейки памяти. Они резервируются системой с учетом типа используемых данных в исходном коде.
4. Константа – постоянное значение. Оно не подлежит никаким корректировкам на протяжении всего жизненного цикла софта.
5. Аргумент – значение, которое передается в команду или функцию.
6. Объекты – наборы связанных между собой переменных, констант и иных структурных данных, выбираемых и обрабатываемых совместно.
7. Классы – перечни связанных объектов. Наделяются общими свойствами.
8. Итерация – один проход через команду или функцию в коде.

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

Основные операторы

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

Всего в рассматриваемом ЯП несколько типов операторов:

• арифметические;
• сравнения;
• присваивания;
• логические;
• принадлежности;
• битовые;
• тождественные.

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

Арифметические

Арифметические операторы в Python – самые простые. Данная категория «команд» встречается даже новичкам. С ними знакомятся еще в школьной программе. Они отвечают за элементарные математические действия.

1. Сложение (+). Производит сложение значений по обе стороны «команды».
2. Вычитание (-). Осуществляет вычитание правой стороны из значения левой в заданном выражении.
3. Умножение (*). Перемножает написанное с обеих сторон выражения.
4. Деление (/). Делит левый операнд на правый. Тип информации результата – это число с плавающей точкой.
5. Возведение в степень (**). Отвечает за возведение первого написанного числа в степень второго у заданной функции.
6. Деление без остатка (//). Производит деление согласно установленным математическим правилам. После этого возвращает значение, оставляя только целочисленную часть от полученного частного. Все, что идет после десятичной точки, система отбросит.
7. Остаток от деления (%). Эта операция также называется делением по модулю. При ее использовании происходит «раздел» и возврат значения остатка.

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

Сравнение

Операторы сравнения отвечают за проверку заданного в приложении равенства. Они указывают, каким является один из операндов:

1. Меньше (<). True присваивается, если показатель слева меньше, чем справа.
2. Больше (>). True на выходе будет получено, когда «условия» слева больше правого.
3. Меньше или равно (<=). Выдает на выходе истину, если левая часть меньше или такая же, как правая.
4. Больше или равно (>=). True устанавливается, если левая часть записи окажется больше или аналогичной правой.
5. Равно (==). В данном случае происходит проверка на непосредственное равенство. Если параметр слева такой же, как справа, на выходе получится true. В противном случае – False.
6. Не равно (!=). Оператор, который убран в Питоне 3. Он проверяет, не равен ли параметр слева правому. При успешном выполнении условия приложение выдаст True.

Здесь в основном придется учитывать результат в виде True и False. Перечисленные манипуляции тоже достаточно активно используются в разработке софта.

Присваивание

Операторы присваивания будут отвечать за передачу переменной того или иного значения. Тут нет true или false. Данная категория включает в себя:

1. Обычное присваивание (=). Параметр справа передается левой части.
2. Сложение и присваивание (+=). Суммирует параметры с обеих сторон и передает результат левой части.
3. Вычитание и присваивание (-=). Из правого вычитается «левое». Далее последнему передается соответствующий результат.
4. Деление и присваивание (/=).
5. Умножение и присваивание (*=).
6. Деление по модулю и присваивание (%=).
7. Возведение в степень и присваивание (**=).
8. Деление с остатком и присваивание (//=).

Последний является одним из самых важных в Питоне.

Логические операторы

Логические операторы выполняют роль своеобразных союзов. Они будут выдавать на выходе True или False. Дают возможность объединения нескольких условий в единое целое:

1. И (and). Если написанное с двух сторон оператора – это true, то и все выражение окажется true.
2. Или (or). Результат «ложь» выводится тогда, когда два операнда false. В противном случае – true.
3. Не (not). Работает с булевыми значениями. True становится False. Обратное соотношение тоже действует.

Других логических операторов в рассматриваемом языке программирования нет.

Принадлежность

Зато есть операторы принадлежности. Они проверяют, является ли значение частью заданной последовательности: списка, кортежа, строки:

1. В (in). Осуществляет проверку на принадлежность к последовательности. Возвращает True при соответствии указанному условию.
2. Нет в (not in). Проводит проверку на НЕ принадлежность к последовательности.

Других операторов в данной категории нет.

Тождественность

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

1. Это (is). Если тождественность есть, осуществляется возврат True.
2. Это нет (is not).

Остается изучить последнюю крупную категорию операторов в Питоне.

Битовые операторы

Осуществляют работу над операндами побитово. Здесь можно увидеть:

1. Бинарное И (&). Отвечает за побитовую операцию and.
2. Или (|). Побитово проводит or.
3. Или нет (^). Это – исключающее или (XOR).
4. Инвертирующий оператор (

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

Программирование и научные вычисления на языке Python/§2

Здесь мы рассмотрим новый пример — перевод значения температуры из шкалы Фаренгейта в шкалу Цельсия. Мы узнаем о старшинстве арифметических операций, об использовании встроенных математических функции, например e(x) или sin(x), о том как можно использовать интерактивную оболочку Python в качестве калькулятора. Кроме того, мы поговорим об ошибках — ошибке целочисленного деления и погрешности вычислений. Для тех, кто знаком с комплексной переменной, я расскажу о том как с ней работать в Python. После этого урока в своих вычислениях вы сможете обходиться без инженерного калькулятора.

Содержание

Другая формула: Цельсий/Фаренгейт [ править ]

Следующим нашим примером послужит формула для перехода от градусов Цельсия в соответствующее значение по Фаренгейту:

В этой формуле символу С соответствует температура в градусах шкалы Цельсия, а символу F — температура в градусах шкалы Фаренгейта. Наша цель состоит в том, чтобы написать программу, которая расчитывает F, когда мы знаем С.

Ошибка целочисленного деления [ править ]

Если написать решение, основываясь только на тех знаниях, что мы получили из предыдущего урока, то получим для температуры, например, 21 градус по Цельсию, следующий текст:

Когда вы запустите программу, программа напишет результат: 53. Вроде бы все работает. Но не стоит забывать о проверке результатов. В этом случае легко проверить результат, в столбик или на калькуляторе:

Но что мы сделали не так? Ведь формула в программе выглядит правильно. Ошибка в нашей программе одна из самых часто распространенных ошибок, которые по незнанию делают новички. В многих языках программирования существует два типа деления (division): «float division» и «integer division». Float division именно то, чего мы ждем математически: 9/5 равно 1.8, то есть число с плавающей (float) запятой.

Integer division для деления целых чисел в результате дает целое число, отрезая часть после точки, то есть «округляя вниз», до ближайшего меньшего целого, в нашем случае до единицы. То есть целочисленное деление рассматривает сколько целых делителей может поместиться в делимом. Это означает что для целочисленного деления 9/5 = 1. Другие примеры: 16/6 = 2, 1/5 = 0, но заметьте: 18/3 = 6. Многие языки программирования, включая Fortran, C, C++, Java и в том числе Python интерпретируют операцию деления a/b как integer division (целочисленное деление) когда оба числа a и b целые. Если хотя бы один из них является числом с плавающей точкой, то применяется обычное математическое деление.

Проблема нашей программы заключалась именно в целочисленном делении, поскольку часть формулы содержит выражение 9/5. Несложно проследить как получилось число 53. 9/5 в целочисленном делении дает 1, 1 умножается на 21 и в итоге 21 + 32 = 53. Очень скоро мы узнаем как двумя символами можно решить эту проблему и написать корректно работающую программу, но сначала будет полезно познакомиться с часто встречающемся в программировании на Python слове объект (object).

Замечание: В версии Python 3.3 ситуация с делением обстоит так: Integer division отвечает символ «//», float division — «/»

Объекты в Python [ править ]

Python создает int (integer, целочисленный) объект и присваивает ему значение 21. Переменная C действует, как имя этого int object. Также, если бы мы написали C = 21.0, Python бы определил это число как float, создал бы соответствующий float объект и присвоил ему значение 21. Таким образом, рассматривая любое выражение присваивания (assignment statement), с левой стороны от знака равенства мы видим имя переменной, а справа от знака равенства видим объект. Можно сказать, что программирование на Python заключается в определении и изменении объектов.

Самое важное, что стоит сейчас понять, что для математики безразлично, напишите вы 21 или 21.0, но в программе Python это две разные вещи: 21 — это объект целого (int) типа, 21.0 — объект типа float. Эти объекты расположены где-то в разных частях компьютерной памяти, и, когда программа встречает переменную, например С, она вызывает нужный объект из нужной области памяти. Причина наличия двух таких типов в том, что числа типа int занимают в памяти меньше места, значит, если в решении задачи не требуется дробных чисел, то работать с целыми числами (числами типа int) программа будет быстрее, выгоднее.

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

Как избежать целочисленного деления [ править ]

Существует несколько способов сделать это. Наиболее широко используемый метод уже упоминался. Нам просто нужно, чтобы хотя бы один операнд (или делимое, или делитель, или оба вместе) был объектом не типа int, а типа float. Тогда float division просто гарантировано. Как это сделать:

Теперь мы знаем почему неправильно работала первая версия нашей программы и как избежать ошибки. Кстати, мы могли получить ту же ошибку еще на первом уроке, если бы вместо 0.5*g*t**2 написали (1/2)*g*t**2 и долго бы думали почему у нас мячик не хочет подпрыгивать и всегда остается в руке (в y = 0). Корректно работающая версия нашей программы теперь выглядит так:

Старшинство арифметических операций [ править ]

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

Пусть имеется некоторая переменная a. Проиллюстрируем ее карьерный рост в двух примерах

1. 5/9+2*a**4/2: сначала считается 5/9, целочисленное деление дает 0, затем a возводится в четвертую степень и умножается на 2, а затем делится на два. В итоге получаем a 4 .

2. 5/(9+2)*a**(4/2): сначала считается первая скобка получается 11, 5/11 дает 0. Потом считается вторая скобка, получается 2, и a возводится в квадрат. Потом квадрат a 2 умножается на 0 и получается 0.

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

Стандартные математические функции [ править ]

В математических формулах встречаются такие функции как sin, cos, tan, sinh, cosh, exp, log и так далее. В инженерном калькуляторе есть специальные кнопки для таких функций. Также и в написании программы на Python вы можете использовать такие встроенные функции.

Пример: извлечение квадратного корня [ править ]

Вспомним наш первый урок и пример о вертикальном движении мяча. Мы определяли координату y в определенный момент времени. Но представим, нам теперь интересно узнать обратное — через сколько времени окажется мячик в определенной координате y_c.

  t 1 = v 0 − v 0 2 − 2 g y c g , t 2 = v 0 + v 0 2 − 2 g y c g <\displaystyle

Два значения времени физически объясняются тем, что мяч оказывается в одной и той же точке два раза: пока он летит наверх (t = t₁), и обратно — вниз (t = t₂ > t₁). Чтобы записать полученные выражения для t₁ и t₂ в программе, у нас должна быть некая функция, извлекающая квадратный корень, также как на калькуляторе для этого есть специальная кнопка. В Python, функция, извлекающая квадратный корень и множество других функции доступны в модуле, который называется math. Чтобы ими пользоваться мы просто должны импортировать этот модуль в программу, написав перед тем местом, где мы будем использовать функции, import math. После этого, чтобы взять квадратный корень от переменной a мы пишем math.sqrt(a). Вот как, например, будет выглядеть наша программа:

At t=0.0417064 s and 0.977662 s, the height is 0.2 m.

import и from . import [ править ]

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

Чтобы вызвать функцию нужно записать имя_модуля.имя_функции(), например для присваивания переменной ‘x’ квадратного корня из переменной ‘y’ записывают:

Люди, часто работающие с математическими функциями, найдут запись math.sqrt(y) менее удобной, чем sqrt(y). К счастью, есть альтернативный способ, позволяющий использовать функцию без префикса имени модуля. Этот альтернативный способ имеет вид «from module import function». Например:

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

Иногда даже пишут:

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

import as [ править ]

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

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

Пример: другие математические функции [ править ]

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

Для того, чтобы вызвать гиперболический синус, мы можем использовать три способа: 1) самый простой — вызвать встроенную функцию math.sinh( ), 2)использовать два раза функцию math.exp( ), 3) использовать возведение в степень числа e. Сравним в небольшой программе, как это будет выглядеть и получаемые результаты:

На выходе имеем идентичные результаты:

267.744894041 267.744894041 267.744894041 Чисто технически расчёт для r1 по времени самый короткий, и именно его стоит использовать в программах. Кроме всего прочего, не стоит забывать, что обращение к локально объявленным функциям происходит быстрее, чем к функции из другого модуля(s=math.sinh вместо math.sinh).

dir( ) и help( ) [ править ]

Для того, чтобы посмотреть все, что вы можете извлечь из какого-либо модуля, достаточно после того как вы его импортировали в интерактивном режиме, написать dir(имя_модуля). Например, это может выглядеть так:

Имена с двумя подчеркиваниями относятся к системным, и о них мы поговорим несколькими уроками позже. Все остальные — это функции и константы, все, что мы непосредственно используем. Для того, чтобы узнать о назначении каждой функции, достаточно написать help(имя_модуля.имя_функции). Аналогично можно просмотреть и всю информацию о модуле, например help(math).

Ошибки округления [ править ]

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

И тогда на выходе:

267.7448940410164369 267.7448940410164369 267.7448940410163232

Теперь r1 и r2 равны, но r3 отличается в последних четырех знаках.

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

Причина, по которой мы не получаем 1.0 в первом случае заключена в том, что 1/49 не может быть представлена в памяти компьютера корректно. На самом деле и 1/51 неточно записывается в памяти, но эта неточность не видна в конечном результате.

В итоге, ошибки в числах с плавающей точкой могут накапливаться в наших математических вычислениях и результаты будут являться аппроксимацией к абсолютно точным, «природным» ответам. Эти ошибки называются round-off errors, ошибки округления, ошибки точности. В Python есть специальный модуль decimal, позволяющий представлять действительные числа с регулируемой точностью, то есть снижать погрешность до любых требуемых значений. Однако, мы практически не будем пользоваться этим модулем, поскольку большинство используемых математических методов и так приближены, и вносят гораздо большую неточность, чем round-off errors. Более того, в расчётах из области радиоэлектроники, например, три значащих цифры в параметрах какого-либо элемента являются вполне достаточными.

Числа с фиксированной точностью [ править ]

Начиная с версии Python 2.4 появился новый числовой тип: числа с фиксированной точностью представления. Такие числа создаются с помощью вызова из специального модуля decimal. Числа эти похожи на числа с плавающей запятой, но число знаков после запятой здесь фиксировано, отсюда и такое название. То есть так можно хранить число, которое всегда будет иметь, например, два знака после запятой. Кроме того, можно указать, как должны обрабатываться лишние десятичные знаки — просто отсекаться или округляться. Скорость работы с такими числами, конечно, меньше, но они могут быть востребованы в областях, где сохранение точности может быть существенно важным, например, в вопросах финансов.

Разговор о точности работы с обычными числами дополняет и следующий простой пример:

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

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

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

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

Интерактивное программирование [ править ]

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

Interactive Shell [ править ]

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

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

Следующий шаг — обновить выражения, в которых еще содержится старое значение, то есть нашу формулу для y. В таком редакторе как IPython можно найти предыдущее выражение, с помощью кнопок со стрелками. О возможностях этого редактора мы еще поговорим. А пока:

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

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

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

Теперь мы преобразуем наш объект С типа int к соответствующему объекту типа float:

В инструкции C = float(C) мы создали новый объект из оригинального объекта с тем же именем. Теперь имя С ссылается на новый объект. Изначальный объект типа int со значением 21 теперь недоступен, поскольку у него больше нет имени и автоматически удаляется из памяти.

Мы также можем сделать и обратное, то есть конвертировать объект типа float к объекту типа int:

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

Комплексные числа [ править ]

Пусть x 2 = 2. Большинство из нас будут способны найти первый корень x = 2 <\displaystyle x=<\sqrt <2>>> . Более продвинутые в математике заметят, что имеется и второй корень x = − 2 <\displaystyle x=-<\sqrt <2>>> . Но встретившись с выражением x 2 = -2 решение смогут найти лишь немногие люди, знакомые с комплексными числами. Если вы только собираетесь стать ученым, настоятельно советуем познакомиться сейчас с этими замечательными числами перед тем, как изучить дальнейшие примеры, на которых вы сможете проверить свои новые знания.

Комплексная арифметика в Python [ править ]

Python поддерживает расчеты с комплексными числами. Мнимая часть записывается через j, вместо i в математике. Комплексное число 2-3i соответственно будет записано как 2-3j. Ниже показан простой сеанс работы с комплексными числами и примеры простой комплексной арифметики:

Кроме того объект типа complex легко может быть разложен на реальную и мнимую части и для него может быть найдено сопряженное (conjugate) число:

Комплексные функции Python [ править ]

Для работы с функциями комплексных переменных следует использовать специальную библиотеку — cmath:

Чему мы научились [ править ]

Теперь мы знаем об ошибке целочисленного деления и как ее избежать, как можно импортировать (import) модули, узнать что в них имеется (dir) и как использовать (help) их функции. Мы познакомились с концепцией объектов в Python и умеем изменять тип объекта (int, float, string). Кроме привычной математики действительных чисел библиотеки math, мы можем пользоваться и комплексной переменной с помощью модуля cmath. Наконец, теперь в случае, когда мы хотим быстро себя проверить, мы можем воспользоваться интерактивной оболочкой IDLE.

Упражнения [ править ]

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