Числа в python
Содержание:
- Комбинации элементов между собой
- Аргументы и параметры
- Встроенные функции
- Как посчитать сумму введенных чисел?
- Для чего нужен модуль Decimal?
- Способы извлечения корня
- Арифметические функции в Python
- Комплексные числа[править]
- Арифметические операции
- Дополнение 1: Как вызывать магические методы
- Решение реальной задачи с использованием sqrt
- Использование Python itertools.chain() для объединения итераций
- Комплексные числа в Python (complex)
- Значения -inf, inf и nan
- Одиночные проверки
Комбинации элементов между собой
В библиотеке есть еще одна функция, связанная с перестановками и комбинациями, называемая . Эта функция является разновидностью функции , с той небольшой разницей, что она включает комбинации элементов между собой.
import itertools values = com = itertools.combinations_with_replacement(values, 2) for val in com: print(*val)
Выход:
1 1 1 2 1 3 1 4 2 2 2 3 2 4 3 3 3 4 4 4
Мы можем видеть четкое отличие вышеприведенного вывода от вывода с теми же параметрами при передаче в функцию .
Есть комбинации чисел, как будто их несколько экземпляров в списке. В основном это происходит потому, что, когда мы выбираем элемент из списка, вышеуказанная функция снова помещает то же значение, чтобы получить комбинации.
Еще пример. Наша задача — отобразить перестановку заданной строки. Здесь решаем эту проблему в python, используя перестановки встроенных функций (итерируемые).
Input : string = 'XYZ'
Output : XYZ
XZY
YXZ
YZX
ZXY
ZYX
Алгоритм
Step 1: given string. Step 2: Get all permutations of string. Step 3: print all permutations.
Пример кода
from itertools import permutations
def allPermutations(str1):
# Get all permutations of string 'ABC'
per = permutations(str1)
# print all permutations
print("Permutation Of this String ::>")
for i in list(per):
print (''.join(i))
# Driver program
if __name__ == "__main__":
str1 = input("Enter the string ::>")
allPermutations(str1)
Вывод
Enter the string ::> abc Permutation Of this String ::> abc acb bac bca cab cba
Аргументы и параметры
В функции можно использовать неограниченное количество параметров, но число аргументов должно точно соответствовать параметрам. Эти параметры представляют собой позиционные аргументы. Также Python предоставляет возможность определять значения по умолчанию, которые можно задавать с помощью аргументов-ключевых слов.
При определении функции параметры со значениями по умолчанию нужно указывать до позиционных аргументов:
Если использовать необязательный параметр, тогда все, что указаны справа, должны быть параметрами по умолчанию.
Выходит, что в следующем примере допущена ошибка:
Для вызовов это работает похожим образом. Сначала нужно указывать все позиционные аргументы, а только потом необязательные:
На самом деле, следующий вызов корректен (можно конкретно указывать имя позиционного аргумента), но этот способ не пользуется популярностью:
А этот вызов некорректен:
При вызове функции с аргументами по умолчанию можно указать один или несколько, и порядок не будет иметь значения:
Можно не указывать ключевые слова, но тогда порядок имеет значение. Он должен соответствовать порядку параметров в определении:
Если ключевые слова не используются, тогда нужно указывать все аргументы:
Второй аргумент можно пропустить:
Чтобы обойти эту проблему, можно использовать словарь:
Значение по умолчанию оценивается и сохраняется только один раз при определении функции (не при вызове). Следовательно, если значение по умолчанию — это изменяемый объект, например, список или словарь, он будет меняться каждый раз при вызове функции. Чтобы избежать такого поведения, инициализацию нужно проводить внутри функции или использовать неизменяемый объект:
Еще один пример изменяемого объекта, значение которого поменялось при вызове:
Дабы не допустить изменения оригинальной последовательности, нужно передать копию изменяемого объекта:
Позиционные аргументы
Иногда количество позиционных аргументов может быть переменным. Примерами таких функций могут быть и . Синтаксис для определения таких функций следующий:
При вызове функции нужно вводить команду следующим образом:
Python обрабатывает позиционные аргументы следующим образом: подставляет обычные позиционные аргументы слева направо, а затем помещает остальные позиционные аргументы в кортеж (*args), который можно использовать в функции.
Вот так:
Если лишние аргументы не указаны, значением по умолчанию будет пустой кортеж.
Произвольное количество аргументов-ключевых слов
Как и в случае с позиционными аргументами можно определять произвольное количество аргументов-ключевых слов следующим образом (в сочетании с произвольным числом необязательных аргументов из прошлого раздела):
При вызове функции нужно писать так:
Python обрабатывает аргументы-ключевые слова следующим образом: подставляет обычные позиционные аргументы слева направо, а затем помещает другие позиционные аргументы в кортеж (*args), который можно использовать в функции (см. предыдущий раздел). В конце концов, он добавляет все лишние аргументы в словарь (**kwargs), который сможет использовать функция.
Есть функция:
Важно, что пользователь также может использовать словарь, но перед ним нужно ставить две звездочки (**):
Порядок вывода также не определен, потому что словарь не отсортирован.
Встроенные функции
Для операции округления в Python есть встроенные функции – и
round
– округляет число (number) до ndigits знаков после запятой. Это стандартная функция, которая для выполнения не требует подключения модуля math.
По умолчанию операция проводится до нуля знаков – до ближайшего целого числа. Например:
Чтобы получить целый показатель, результат преобразовывают в .
Синтаксически функция вызывается двумя способами.
- – это округление числа до целого, которое расположено ближе всего. Если дробная часть равна 0,5, то округляют до ближайшего четного значения.
- – данные округляют до знаков после точки. Если округление проходит до сотых, то равен «2», если до тысячных – «3» и т.д.
int
– встроенная функция, не требующая подключения дополнительных модулей. Её функция – преобразование действительных значений к целому путем округления в сторону нуля. Например
Для положительных чисел функция аналогична функции , а для отрицательных – аналогично . Например:
Чтобы число по int преобразовать по математическим правилам, нужно выполнить следующие действия.
- Если число положительное, добавить к нему 0,5.
- Если число отрицательное, добавить -0,5.
Синтаксически преобразование оформляется так:
Как посчитать сумму введенных чисел?
В команде input() можно передавать подсказки.
w = int(input(«Введите первое число: «)) q = int(input(«Введите второе число: «)) summa=w+q print(summa)
Введите первое число: 6 Введите второе число: 7 13
Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!
Добавляйтесь ко мне в друзья : http://vk.com/myrusakov.Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.
Если Вы не хотите пропустить новые материалы на сайте,то Вы можете подписаться на обновления: Подписаться на обновления
Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.
Порекомендуйте эту статью друзьям:
Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):
Она выглядит вот так:
BB-код ссылки для форумов (например, можете поставить её в подписи):
Для чего нужен модуль Decimal?
Некоторые пользователи задаются вопросом, зачем нам нужен модуль для выполнения простейшей арифметики с десятичными числами, когда мы вполне можем сделать то же самое с помощью чисел с плавающей точкой ?
Перед тем, как мы ответим на данный вопрос, мы хотим, чтобы вы сами посчитали в Python, какой результат будет в данном примере: 0.1+0.2? Вы будете удивлены, когда узнаете, что правильный ответ – это не 0,3, а 0,30000000000000004.
Чтобы понять, почему в расчетах возникла ошибка, попробуйте представить 1/3 в десятичной форме. Тогда вы заметите, что число на самом деле не заканчивается в базе 10. Так как все числа должны быть каким-то образом представлены, при их сохранении в консоли делается несколько приближений, что и приводит к ошибкам.
Cпециально для читателей-гуманитариев, у нас есть объяснение принципов работы модулей Питона: «Она на долю секунды отвела взгляд» и «Она отвела взгляд на короткое время» — чувствуете разницу?
Чтобы получить точные результаты, подобные тем, к которым мы привыкли при выполнении расчетов вручную, нам нужно что-то, что поддерживает быструю, точно округленную, десятичную арифметику с плавающей запятой, и модуль Decimal отлично справляется с этой задачей. Теперь, когда мы разобрались с теорией, переходим к принципам работы десятичного модуля.
Способы извлечения корня
В языке программирования Python 3 существует три способа извлечения корней:
- Использование функции sqrt из стандартной математической библиотеки math.
- Операция возведения в степень **
- Применение функции pow(x, n)
Чтобы воспользоваться первым способом, необходимо вначале импортировать sqrt из модуля math. Это делается с помощью ключевого слова import: . При помощи этой функции можно извлекать только квадратный корень из числа. Приведем пример:
from math import sqrt x = sqrt(4) print(x) 2.0
Если же нам нужно вычислить в Python корень квадратный из суммы квадратов, то можно воспользоваться функцией hypot из модуля math. Берется сумма квадратов аргументов функции, из нее получается корень. Аргументов у функции два.
from math import hypot x = hypot(4,3) print(x) 5.0
Еще одним, чуть более универсальным методом, будет использование возведения в степень. Известно, что для того, чтобы взять корень n из числа, необходимо возвести его в степень 1/n. Соответственно, извлечение квадратного корня из числа 4 будет выглядеть так:
n = 2 x = 4**(1./n) print(x) 2.0
Обратите внимание, что в Python 2 необходимо ставить точку после единицы, иначе произойдет целочисленное деление, и 1/n == 0, а не нужной нам дроби. В Python 3 можно не ставить точку.. Последний метод использует функцию pow(value, n)
Эта функция в качестве аргумента value возьмет число, которое необходимо возвести в степень, а второй аргумент будет отвечать за степень числа. Как и в предыдущем методе, необходимо использовать дробь, для того, чтобы получить корень числа
Последний метод использует функцию pow(value, n). Эта функция в качестве аргумента value возьмет число, которое необходимо возвести в степень, а второй аргумент будет отвечать за степень числа. Как и в предыдущем методе, необходимо использовать дробь, для того, чтобы получить корень числа.
x = pow(4, 0.5) print(x) 2.0
Какой метод быстрее?
Для того, чтобы определить какой же метод предпочтительнее использовать, напишем программу. Замерять время выполнения будем с помощью метода monotonic библиотеки time.
from time import monotonic
from math import sqrt
iterations = 1000000
start = monotonic()
for a in range(iterations):
x = sqrt(4)
print("sqrt time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
x = 4 ** 0.5
print("** time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
x = pow(4, 0.5)
print("pow time: {:>.3f}".format(monotonic() - start) + " seconds")
sqrt time: 0.266 seconds
** time: 0.109 seconds
pow time: 0.453 seconds
Как видно, самое быстрое решение – использовать **. На втором месте метод sqrt, а pow – самый медленный. Правда, метод sqrt наиболее нагляден при вычислении в Python квадратных корней.
Таким образом, если критична скорость, то используем **. Если скорость не критична, а важна читаемость кода, то следует использовать sqrt.
Арифметические функции в Python
Арифметические функции используются для представления чисел в различных формах и осуществления над ними математических операций. Далее представлен перечень самых популярных арифметических функций:
- : округление определенного числа вверх;
- : возвращает модуль (абсолютное значение) указанного числа;
- : округление определенного числа вниз;
- : получение наибольшего общего делителя чисел и ;
- : возвращает сумму всех элементов итерируемого объекта;
- : возвращает (e^x)-1;
- : когда значение слишком мало, вычисление может привести к значительной потери в точности. может вернуть вывод с полной точностью.
В следующем примере показано использование перечисленных выше функций:
Python
import math
num = -4.28
a = 14
b = 8
num_list =
x = 1e-4 # Малое значение x
print(‘Число:’, num)
print(‘Округление числа вниз:’, math.floor(num))
print(‘Округление числа вверх:’, math.ceil(num))
print(‘Модуль числа:’, math.fabs(num))
print(‘Наибольший общий делитель a и b: ‘ + str(math.gcd(a, b)))
print(‘Сумма элементов списка: ‘ + str(math.fsum(num_list)))
print(‘e^x (при использовании функции exp()) равно:’, math.exp(x)-1)
print(‘e^x (при использовании функции expml()) равно:’, math.expm1(x))
|
1 |
importmath num=-4.28 a=14 b=8 num_list=10,8.25,75,7.04,-86.23,-6.43,8.4 x=1e-4# Малое значение x print(‘Число:’,num) print(‘Округление числа вниз:’,math.floor(num)) print(‘Округление числа вверх:’,math.ceil(num)) print(‘Модуль числа:’,math.fabs(num)) print(‘Наибольший общий делитель a и b: ‘+str(math.gcd(a,b))) print(‘Сумма элементов списка: ‘+str(math.fsum(num_list))) print(‘e^x (при использовании функции exp()) равно:’,math.exp(x)-1) print(‘e^x (при использовании функции expml()) равно:’,math.expm1(x)) |
Вывод
Python
Число: -4.28
Округление числа вниз: -5
Округление числа вверх: -4
Модуль числа: 4.28
Наибольший общий делитель a и b: 2
Сумма элементов списка: 16.029999999999998
e^x (при использовании функции exp()) равно: 0.0001000050001667141
e^x (при использовании функции expml()) равно: 0.00010000500016667084
|
1 |
Число-4.28 Округлениечиславниз-5 Округлениечиславверх-4 Модульчисла4.28 Наибольшийобщийделительaиb2 Суммаэлементовсписка16.029999999999998 e^x(прииспользованиифункцииexp())равно0.0001000050001667141 e^x(прииспользованиифункцииexpml())равно0.00010000500016667084 |
К числу других математических функций относятся:
- : принимает два вещественных аргумента, возводит первый аргумент в степень, значением которой является второй аргумент, после чего возвращает результат. К примеру, эквивалентно выражению ;
- : возвращает квадратный корень определенного числа.
Примеры данных методов представлены ниже:
Возведение в степень
Python
math.pow(3, 4)
| 1 | math.pow(3,4) |
Вывод
Shell
81.0
| 1 | 81.0 |
Квадратный корень
Python
math.sqrt(81)
| 1 | math.sqrt(81) |
Вывод
Shell
9.0
| 1 | 9.0 |
Комплексные числа[править]
Пусть x2 = 2. Большинство из нас будут способны найти первый корень x=2{\displaystyle x={\sqrt {2}}}. Более продвинутые в математике заметят, что имеется и второй корень x=−2{\displaystyle x=-{\sqrt {2}}}. Но встретившись с выражением x2 = -2 решение смогут найти лишь немногие люди, знакомые с комплексными числами. Если вы только собираетесь стать ученым, настоятельно советуем познакомиться сейчас с этими замечательными числами перед тем, как изучить дальнейшие примеры, на которых вы сможете проверить свои новые знания.
Комплексная арифметика в Pythonправить
Python поддерживает расчеты с комплексными числами. Мнимая часть записывается через j, вместо i в математике. Комплексное число 2-3i соответственно будет записано как 2-3j. Ниже показан простой сеанс работы с комплексными числами и примеры простой комплексной арифметики:
>>> u = 2.5 + 3j # создаем комплексное >>> v = 2 # а это целое >>> w = u + v # комплексное + целое >>> w (4.5+3j) >>> a = -2 >>> b = 0.5 >>> s = a + b*1j # complex из двух float >>> s = complex(a, b) # другой способ >>> s (-2+0.5j) >>> s*w # complex*complex (-10.5-3.75j) >>> sw # complex/complex (-0.25641025641025639+ 0.28205128205128205j)
Кроме того объект типа complex легко может быть разложен на реальную и мнимую части и для него может быть найдено сопряженное (conjugate) число:
>>> s.real -2.0 >>> s.imag 0.5 >>> s.conjugate() (-2-0.5j)
Комплексные функции Pythonправить
Для работы с функциями комплексных переменных следует использовать специальную библиотеку — cmath:
>>> from cmath import sin, sinh >>> r1 = sin(8j) >>> r1 1490.4788257895502j >>> r2 = 1j*sinh(8) >>> r2 1490.4788257895502j
Арифметические операции
Целые числа поддерживают следующие математические операции, которые отсортированы по убыванию приоритета:
| № | Операция | Результат | Замечание |
|---|---|---|---|
| 1 | возводит x в степень y | (I) | |
| 2 | возводит x в степень y по модулю z, где z – необязательный аргумент | (I) | |
| 3 | возвращает кортеж с парой чисел | (II) | |
| 4 | возвращает \(\bar{x}\) — число, которое комплексно сопряжено с \(x\) | ||
| 5 | преобразует re в комплексное число (по умолчанию ) | (V) | |
| 6 | преобразует x в вещественное число (число с плавающей точкой) | (V) | |
| 7 | переобразует x в целое число, представленное в десятичной системе счисления | (V) | |
| 8 | абсолютное значение (модуль) числа x | ||
| 9 | делает число x положительным | ||
| 10 | делает число x отрицательным | ||
| 11 | остаток от деления x на y | (II) | |
| 12 | результат целочисленного деления x на y | (III) (II) | |
| 13 | результат «истинного» деления x на y | ||
| 14 | произведение x и y | ||
| 15 | разность x и y | ||
| 16 | сумма x и y |
Важно: приоритет математических операций выше побитовых логических операций и операций сравнения.
Замечания:
I. возведение \(0\) в степень \(0\) возвращает \(1\):
Извлечение корней четной степени из отрицательных чисел не вызывает ошибки, а возвращает комплексное число:
Использование в выражении слишком больших значений x и y типа может привести к ошибке OverflowError.
II. функция и операции , не работают для комплексных чисел. Для вас это может быть и очевидно, но не пользователя для которого вы пишите программу.
III. Данная операция всегда возвращает целое число, т.е. если число x можно представить в виде , то (r – остаток от деления). Так же следует иметь ввиду, что результат данной операции всегда округляется в сторону минус бесконечности:
Это немного сбивает с толку, но проверив результат по формуле , вы убедитесь что все верно.
IV. встроенная функция отбрасывает дробную часть вещественных чисел:
V. строго говоря эти функции не являются математическими, но они могут учавствовать в математических выражениях Python и поэтому должны обладать приоритетом.
Дополнение 1: Как вызывать магические методы
| Магический метод | Когда он вызывается (пример) | Объяснение |
|---|---|---|
| вызывается при создании экземпляра | ||
| вызывается при создании экземпляра | ||
| , , etc. | Вызывается для любого сравнения | |
| Унарный знак плюса | ||
| Унарный знак минуса | ||
| Побитовая инверсия | ||
| Преобразование, когда объект используется как индекс | ||
| , | Булевое значение объекта | |
| Пытаются получить несуществующий атрибут | ||
| Присвоение любому атрибуту | ||
| Удаление атрибута | ||
| Получить любой атрибут | ||
| Получение элемента через индекс | ||
| Присвоение элементу через индекс | ||
| Удаление элемента через индекс | ||
| Итерация | ||
| , | Проверка принадлежности с помощью | |
| «Вызов» экземпляра | ||
| оператор менеджеров контекста | ||
| оператор менеджеров контекста | ||
| Сериализация | ||
| Сериализация |
Решение реальной задачи с использованием sqrt
Корень – дитя геометрии. Когда Пифагор доказал свою знаменитую теорему, людям тут же захотелось вычислять стороны треугольников, проверять прямоту внешних углов и сооружать лестницы нужной длины.
Соотношение a2 + b2 = c2, где «a» и «b» – катеты, а «c» – гипотенуза – естественным образом требует извлекать корни при поиске неизвестной стороны. Python-а под рукой у древних греков и вавилонян не было, поэтому считать приходилось методом приближений. Жизнь стала проще, но расчет теоремы Пифагора никто не отменял и в XXI веке.
Решим задачку про вышку сотовой связи. Заказчик требует рассчитать высоту сооружения, чтобы радиус покрытия был 23 километра. Мы неспешно отходим на заданное расстояние от предполагаемого места строительства и задумчиво смотрим под ноги. В голове появляются очертания треугольника с вершинами:
- Ваше местоположение;
- Центр Земли;
- Пиковая высота вышки;
Модель готова, приступаем к написанию кода:
Расчёт выполнен, результат заказчику предоставлен. Можно идти пить чай и радоваться тому, что теперь ещё больше людей смогут звонить родным и сидеть в интернете.
Использование Python itertools.chain() для объединения итераций
Метод Python генерирует итератор из нескольких итераций.
Это просто связывает все итераторы вместе в одну последовательность и возвращает единственный итератор для этой объединенной последовательности.
Синтаксис этого метода следующий
iterator = itertools.chain(*sequence)
Давайте посмотрим на простой пример.
import itertools
list1 =
list2 =
dict1 = {'site': 'AskPython', 'url': 'https://askpython.com'}
# We can combine lists and dicts (iterables) into a single chain
for item in itertools.chain(list1, list2, dict1):
print(item)
Здесь мы используем итератор напрямую, перебирая его, используя
Выход
hello from AskPython 10 20 30 40 50 site url
Хотя мы получаем содержимое наших списков правильно, значения словаря не отображаются.
Чтобы исправить это, мы могли бы использовать для получения кортежа пар .
import itertools
list1 =
list2 =
dict1 = {'site': 'AskPython', 'url': 'https://askpython.com'}
# We can combine lists and dicts (iterables) into a single chain
for item in itertools.chain(list1, list2, dict1.items()):
print(item)
Выход
hello
from
AskPython
10
20
30
40
50
('site', 'AskPython')
('url', 'https://askpython.com')
Теперь у нас также есть напечатанные значения.
Комплексные числа в Python (complex)
Также в Python встроены комплексные числа:
>>> >>> x = complex(1, 2) >>> print(x) (1+2j) >>> y = complex(3, 4) >>> print(y) (3+4j) >>> z = x + y >>> print(x) (1+2j) >>> print(z) (4+6j) >>> z = x * y >>> print(z) (-5+10j) >>> z = x y >>> print(z) (0.44+0.08j) >>> print(x.conjugate()) # Сопряжённое число (1-2j) >>> print(x.imag) # Мнимая часть 2.0 >>> print(x.real) # Действительная часть 1.0 >>> print(x > y) # Числа нельзя сравнить Traceback (most recent call last): File "", line 1, in TypeError unorderable types complex() > complex() >>> print(x == y) # Однако можно проверить их на равенство False >>> abs(3 + 4j) # Модуль 5.0 >>> pow(3 + 4j, 2) # Возведение в степень, получение значения степени (-7+24j)
Кроме того, для работы с complex может применяться модуль cmath.
На этом пока что всё. Следите за новостями и не забывайте оставлять свои комментарии!
Значения -inf, inf и nan
Тем не менее вместо ошибок OverflowError, когда число выходит за указанные пределы, иногда появляются значения и :
Возможно, к появляению ошибки OverflowError приводит только операция возведения в степень (скорее всего, хотя может я и не прав, точные причины возникновения данной ошибки кроются где-то в недрах языка C, на котором реализован интерпретатор CPython). Все что нужно знать о значениях и это то что это числа обозначающие плюс минус бесконечность. Да, это на самом деле числа числа с плавающей запятой, которые могут учавствовать в выражениях:
Однако, что бы вы не делали с бесконечностью, она так и останется бесконечностью. Единственное что можно попробовать, так это вычесть из одной бесконечности другую бесконечность:
И мы получили — значение, которое означает неопределяемое число (или «не число»). Но оно ведет себя как число, и в каком бы выражении оно не появилось, результат всегда будет (кроме т.к. деление на \(0\) всегда приводит к появлению ошибки):
В реальной жизни, вы скорее всего никогда не встретитесь с значениями , и , если только не собираетесь заниматься какими-нибудь весьма специфичными вычислениями. Но, как правило, тех, кто встречается с этими значениями впервые, почему-то смущает, то что они не понимают откуда берутся и как действуют эти значения.
Одиночные проверки
Внутри условия
можно прописывать и такие одиночные выражения:
x = 4; y = True; z = False
if(x): print("x = ", x, " дает true")
if(not ): print("0 дает false")
if("0"): print("строка 0 дает true")
if(not ""): print("пустая строка дает false")
if(y): print("y = true дает true")
if(not z): print("z = false дает false")
Вот этот оператор
not – это отрицание
– НЕ, то есть, чтобы проверить, что 0 – это false мы
преобразовываем его в противоположное состояние с помощью оператора отрицания
НЕ в true и условие
срабатывает. Аналогично и с переменной z, которая равна false.
Из этих примеров
можно сделать такие выводы:
-
Любое число,
отличное от нуля, дает True. Число 0 преобразуется в False. -
Пустая строка –
это False, любая другая
строка с символами – это True. - С помощью
оператора not можно менять
условие на противоположное (в частности, False превращать в True).
Итак, в условиях
мы можем использовать три оператора: and, or и not. Самый высокий
приоритет у операции not, следующий приоритет имеет операция and и самый
маленький приоритет у операции or. Вот так работает оператор if в Python.
Видео по теме
Python 3 #1: установка и запуск интерпретатора языка
Python 3 #2: переменные, оператор присваивания, типы данных
Python 3 #3: функции input и print ввода/вывода
Python 3 #4: арифметические операторы: сложение, вычитание, умножение, деление, степень
Python 3 #5: условный оператор if, составные условия с and, or, not
Python 3 #6: операторы циклов while и for, операторы break и continue
Python 3 #7: строки — сравнения, срезы строк, базовые функции str, len, ord, in
Python 3 #8: методы строк — upper, split, join, find, strip, isalpha, isdigit и другие
Python 3 #9: списки list и функции len, min, max, sum, sorted
Python 3 #10: списки — срезы и методы: append, insert, pop, sort, index, count, reverse, clear
Python 3 #11: списки — инструмент list comprehensions, сортировка методом выбора
Python 3 #12: словарь, методы словарей: len, clear, get, setdefault, pop
Python 3 #13: кортежи (tuple) и операции с ними: len, del, count, index
Python 3 #14: функции (def) — объявление и вызов
Python 3 #15: делаем «Сапер», проектирование программ «сверху-вниз»
Python 3 #16: рекурсивные и лямбда-функции, функции с произвольным числом аргументов
Python 3 #17: алгоритм Евклида, принцип тестирования программ
Python 3 #18: области видимости переменных — global, nonlocal
Python 3 #19: множества (set) и операции над ними: вычитание, пересечение, объединение, сравнение
Python 3 #20: итераторы, выражения-генераторы, функции-генераторы, оператор yield
Python 3 #21: функции map, filter, zip
Python 3 #22: сортировка sort() и sorted(), сортировка по ключам
Python 3 #23: обработка исключений: try, except, finally, else
Python 3 #24: файлы — чтение и запись: open, read, write, seek, readline, dump, load, pickle
Python 3 #25: форматирование строк: метод format и F-строки
Python 3 #26: создание и импорт модулей — import, from, as, dir, reload
Python 3 #27: пакеты (package) — создание, импорт, установка (менеджер pip)
Python 3 #28: декораторы функций и замыкания
Python 3 #29: установка и порядок работы в PyCharm
Python 3 #30: функция enumerate, примеры использования
