Все операторы python. синтаксис и примеры кода
Содержание:
Содержание
На сегодняшний день Python является одним из самых популярных языков программирования. Это интерпретируемый высокоуровневый язык с элегантным и легко читаемым синтаксисом. Но Python, как правило, значительно медленнее, чем Java, C#, особенно C и C++, а также Fortran. И иногда вопросы производительности могут сильно влиять на возможность полноценно использовать приложения.
К счастью, есть решения для улучшения производительности программ на Python. И у разработчиков есть возможности увеличить скорость выполнения кода. Например, широко распространена практика использовать оптимизированные процедуры, обычно написанные на C или Cython. Они могут быть частью как самого языка Python, так и сторонних библиотек. Кроме того, работу можно ускорить, если пользоваться не глобальными, а локальными переменными. Поэтому копирование глобальной переменной в локальную перед циклом считается хорошим стилем.
И наконец, всегда есть возможность написать функции Python на C, C++ или Cython и вызывать их потом из Python-приложения, ликвидировав таким образом узкие места в программе. Но это уже крайняя мера, и на практике так делать приходится редко.
Очень часто вопросы производительности возникают при использовании циклов с большим количеством итераций. И существует большое количество полезных приемов, позволяющих ускорить код. Но это уже выходит за рамки настоящего обзора.
В нашей статье мы будет сравнивать производительность различных способов поэлементного суммирования двух последовательностей. А именно:
- с использованием цикла ;
- с использованием цикла ;
- с использованием представления списков;
- с использованием библиотеки NumPy;
Но производительность это не главное при разработке программного обеспечения. Более того, как сказал Дональд Кнут в своей книге «Искусство программирования»: «Поспешная оптимизация — это корень всех (или почти всех) зол в программировании.» В конечном итоге, «важна читаемость (readability counts)». Это сказано в «Дзен Python» Тима Питерса.
Сколько бы имен ни ссылалось на одно значение, каждому из них всегда можно присвоить другое значение независимо от остальных
Если два имени ссылаются на одно значение, это не устанавливает никакой магической связи между самими именами. Присвоив одному из имен новое значение, вы никоим образом не затронете другое.
Утверждая, что , мы не имеем в виду, что они всегда будут тождественны. Присвойте новое значение — и останется в одиночестве. Вы только представьте, какой хаос был бы в противном случае!
Важно отметить, что Python не позволяет сделать одно имя ссылкой на другое, у него просто нет подобного механизма. Таким образом, вы не сможете сделать постоянным псевдонимом для , не теряющим свой статус даже при смене значения
Операторы назначения
Оператор назначения используется для назначения значений переменной. Это обычно сочетается с другими операторами (например, арифметическими, побитовыми), где операция выполняется на операндах, и результат присваивается левый операнд.
Рассмотрим следующие примеры, А Отказ Здесь это оператор назначения, и результат хранится в переменной A. А Отказ Здесь это оператор назначения, и результат хранится в переменной A. Это так же, как + 10.
| = | |
| + = | A эквивалентно + 5 |
| -= | А эквивалентно – 5 |
| знак равно | A эквивалентно * 3 |
| /= | A эквивалентно / 3 |
| знак равно | А эквивалентно% 3 |
| знак равно | A эквивалентно ** 3 |
| //= | A эквивалентно // 3 |
| знак равно | A эквивалентно и 3 |
| | = | А эквивалентно | 3. |
| ^ = | А эквивалентно ^ 3 |
| >> = | A эквивалентно >> 3 |
| << = | A эквивалентно << 3 |
Порядок вычисления¶
Если имеется выражение вида , что производится раньше: сложение
или умножение? Школьный курс математики говорит нам, что умножение должно
производиться в первую очередь. Это означает, что оператор умножения имеет
более высокий приоритет, чем оператор сложения.
Следующая таблица показывает приоритет операторов в Python, начиная с самого
низкого (самое слабое связывание) и до самого высокого (самое сильное
связывание). Это означает, что в любом выражении Python сперва вычисляет
операторы и выражения, расположенные внизу таблицы, а затем операторы выше по
таблице.
Эта таблица взята из
и приводится здесь для полноты описания. На практике лучше использовать скобки
для группировки операторов и операндов, чтобы в явном виде указать порядок
вычисления выражений. Заодно это облегчит чтение программы. Более подробно см.
в разделе
ниже.
Приоритет операторов
| Оператор | Описание |
| лямбда-выражение | |
| Логическое “ИЛИ” | |
| Логическое “И” | |
| Логическое “НЕ” | |
| , | Проверка принадлежности |
| , | Проверка тождественности |
|
, , , , , |
Сравнения |
| Побитовое “ИЛИ” | |
| Побитовое “ИСКЛЮЧИТЕЛЬНО ИЛИ” | |
| Побитовое “И” | |
| , | Сдвиги |
| , | Сложение и вычитание |
|
, , , |
Умножение, деление, целочисленное деление и остаток от деления |
| , | Положительное, отрицательное |
| Побитовое НЕ | |
| Возведение в степень | |
| Ссылка на атрибут | |
| Обращение по индексу | |
| Вырезка | |
| Вызов функции | |
| Связка или кортеж | |
| Список | |
| Словарь |
Операторы, о которых мы не упомянули, будут объяснены в дальнейших главах.
self
Рассотрим пример. Пусть у нас есть объект мяч — ball , обладающий атрибутами и методами.
Атрибуты мяча могут быть:
ball.color - цвет, например, красныйball.size - размер, например, маленькийball.price – стоимость мяча
Методы нашего объекта могут выглядеть следующим образом:
ball.Move( ) - перемещение мячаball.Show( ) – вывести характеристики (атрибуты) мяча на экран
Переменная self указывает на конкретный объект экземпляра класса. Доступ к атрибутам и методам осуществляется через переменную self. Это главное назначение переменной self.
Предположим мы создали три мяча — экземпляры класса Ball: ball1, ball2, ball3.Мячи могут иметь разные характеристики, например, как в таблице.
|
Объект |
Self |
Color |
Size |
Price |
|
|
имя объекта |
адрес объекта |
||||
|
ball1 |
адрес 1 |
адрес 1 |
Красный |
Маленький |
10 |
|
ball2 |
адрес 2 |
адрес 2 |
Синий |
Средний |
20 |
|
ball3 |
адрес 3 |
адрес 3 |
Белый |
Большой |
30 |
Переменная self представляет ссылку на экземпляр класса, т.е. содержит адрес объекта. Всем методам класса автоматически передается эта ссылка.
Предположим в классе Ball имеется метод Show( ) – вывести характеристики мяча.
Проверка условий в Python.
Регулярно в программах переменные сравниваются с другими переменными или значениями. Самое простое условия, это проверить равно ли значение переменной конкретному значению.
>>> car = ‘audi’
>>> car == ‘audi’True
Присвоим переменной car значение ‘audi’. Во второй строке проверим равно ли значение переменной car. Двойной знак равно (==) используется для проверки равенства. В итоге Python возвращает значение True, означающий что значения равны. В случае неравенства значений, возвращается False.
>>> car = ‘audi’
>>> car == ‘bmw’False
В Python проверка равенства выполняется с учетом регистра. В случае написания значений с разным регистром, значения получаются не равными.
>>> car = ‘audi’
>>> car == ‘Audi’False
Проверка неравенства.
Проверка неравенства происходит с помощью восклицательного знака и знака равно ( != ). Восклицательный знак представляет отрицание, как и во многих языках программирования.
>>> car = ‘audi’
>>> car != ‘bmw’True
Операторы присваивания
Оператор присваивания (=) используется для присвоения значения левого операнда правому операнду.
Есть несколько составных операторов присваивания, которые выполняют арифметические операции между двумя операндами и затем присваивают значение левому операнду.
- =: простой оператор присваивания;
- + =: складывает два операнда, а затем присваивает значение правому операнду;
- — =: вычитает правый операнд из левого и затем присваивает значение левому операнду;
- * =: умножает оба операнда, а затем присваивает левому;
- / =: делит левый операнд от правого операнда, а затем присваивает значение левому операнду;
- % =: модуль левого и правого операндов, а затем присваивается левому операнду;
- ** =: экспонента для операндов слева направо и затем присвоение левому операнду;
- // =: нижнее деление левого и правого операндов, а затем значение присваивается левому операнду.
a = 10 # simple assignment operator b = 5 a += b # same as a=a+b print(a) # 15 a -= b # same as a=a-b print(a) # 10 a *= b # same as a = a*b print(a) # 50 a /= b # same as a = a/b print(a) # 10.0 a %= b # same as a = a%b print(a) # 0.0 a = 2 b = 4 a **= b # same as a = a**b print(a) # 16 a //= b # same as a = a // b (floor division) print(a) # 4
3.3. Команда if-elif-else.
Команда if-elif-else позволяет проверить сразу несколько условий. Предположим, стоимость билетов кинотеатр изменяется в зависимости от возврата посетителя.
>>> age = 35
>>> if age <= 7
… print(‘Для вас вход бесплатный’)
… elif age < 18
… print(‘Стоимость билета 500 руб’)
… elif age <= 60
… print(‘Стоимость билета 1000 руб’)
… else:
… print(‘Для вас вход бесплатный’)
…Стоимость билета 1000 руб
Код выполняется последовательно, программа вначале проверяет соответствие возраста меньше или равно 7 лет, затем
Важно ставить правильную последовательность условий. К примеру, если мы поставим условие младше или равно 60 в начало, то возраст меньше 7 и 18 не будет работать и программа сразу выдаст результат максимальной стоимости билета.
Наличие секции else в команде if-elif-else необязательно. Ее присутствие позволяет обработать результат, не удовлетворяющий никаким условиям.
Арифметические операторы
Арифметические операторы обычно работают с числами. Есть операторы для сложения, вычитания, умножения, деления, модуля и экспоненциальных операций. Некоторые из этих операторов работают и со строками. Все арифметические операторы — специальные символы.
- +: оператор сложения;
- -: оператор вычитания;
- *: оператор умножения;
- /: оператор деления;
- **: экспоненциальный оператор;
- //: оператор деления.
Давайте посмотрим на пример арифметических операторов в Python.
x = 15
y = 7
sum = x + y
print("addition =", sum)
subtraction = x - y
print("subtraction =", subtraction)
multiplication = x * y
print("multiplication =", multiplication)
division = x / y
print("division =", division)
modulus = x % y
print("modulus =", modulus)
exponent = x ** 2
print("exponent =", exponent)
floor_division = x // y
print("division =", floor_division) # 2
Вывод:
Python поддерживает операторы сложения и умножения для строк.
print("addition of strings =", ("Python" + " " + "Operators"))
print("multiplication of strings =", ("Python" * 2))
Вывод:
addition of strings = Python Operators multiplication of strings = PythonPython
Сравнение при помощи оператора != переменных одного и двух типов
Наш первый пример будет содержать различные способы сравнения двух или более значений переменных разных типов с помощью оператора неравенства.
Мы инициализируем две целочисленные переменные, и . После этого используем знак для сравнения их значений. Результат в виде булева значения будет сохранен в новой переменной . После этого мы выводим значение этой переменной.
x = 5 y = 5 c = x != y print(c) # False
При выполнении этого кода мы получим результат , потому что значения переменных и были равны и имели одинаковый тип данных.
Теперь давайте обновим наш код. Мы объявим три разные переменные, причем только две из них будут иметь одинаковое значение.
После этого мы воспользуемся оператором неравенства , чтобы получить результат сравнения переменных и . В этом случае мы используем оператор неравенства прямо в предложении .
Затем мы сравним переменные и вне предложения print и запишем результат в переменную . После этого используем значение этой переменной в print.
Наконец, мы объявим переменную строкового типа и сравним ее с целочисленной переменной a в предложении print.
a = 3
b = 3
c = 2
print(f'a is not equal to b = {a!= b}')
# a is not equal to b = False
f = a != c
print(f"a is not equal to c = {f}")
# a is not equal to c = True
q = '3'
print(f'a is not equal to q = {a!= q}')
# a is not equal to q = True
В выводе мы видим одно ложное и два истинных значения. Первые два результата мы получили, сравнивая переменные целочисленного типа. Однако последнее сравнение было между переменными целочисленного и строкового типов. И хотя обе переменные были равны 3, одна из них была строковой, а вторая – целочисленной. Поэтому мы получили , значения не равны.
Логические операторы
Говоря на естественном языке (например, русском) мы обозначаем сравнения словами «равно», «больше», «меньше». В языках программирования используются специальные знаки, подобные тем, которые используются в математике: (больше), (меньше), (больше или равно), (меньше или равно), (равно), (не равно).
Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком «равно», и операцию сравнения (два знака «равно»). Присваивание и сравнение – разные операции.
>>> a = 10 >>> b = 5 >>> a + b > 14 True >>> a < 14 - b False >>> a <= b + 5 True >>> a != b True >>> a == b False >>> c = a == b >>> a, b, c (10, 5, False)
В данном примере выражение состоит из двух подвыражений. Сначала происходит сравнение () переменных a и b. После этого результат логической операции присваивается переменной c. Выражение просто выводит значения переменных на экран.
Python Побитовые Операторы
Битовые операторы рассматриваются двоичные числа, чтобы произвести расчет. Python является правилом Побитовая следующим образом:
В качестве переменной в следующей таблице 60, б 13.
| операторы | описание | примеров |
|---|---|---|
| & | Побитовое и оператор: два значения, участвующие в операции, если оба соответствующие биты равны 1, то результат бит равен 1, 0 в противном случае | (A & B) выход 12, бинарная информация: 0000 1100 |
| | | Побитовая или оператор: до тех пор, как два соответствующий двоичный бит равен 1, результирующий бит равен 1. | (A | B) выход 61, бинарная информация: 00111101 |
| ^ | Побитовое исключающее ИЛИ оператор: Когда два соответствующих двоичным немного отличается, и результат 1 | (А ^ б) выход 49, бинарная информация: 00110001 |
| ~ | Битовые операторы: каждый двоичный бит данных инверсии, то есть от 1 до 0, от 0 до 1 | (~ A) -61 выход, бинарная информация: 1100 0011 в символическом виде дополнительного кода двоичного числа. |
| << | Левые операторы мобильной связи: каждый двоичный операнды все осталось некоторое количество битов, указанных цифрой «<<» справа от десятичной ходов, отбрасывая высокие и более низкие 0s. | а << 2 выхода 240 Binary интерпретация: 11110000 |
| >> | Правильные операторы мобильной связи: на каждый двоичный «>>» левый операнд Несколько все в порядке, «>>» справа от числа битов указанного | A >> 2 выход 15, бинарная информация: 0000 1111 |
Следующий пример демонстрирует Python все битовые операции:
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b; # 12 = 0000 1100 print "1 - c 的值为：", c c = a | b; # 61 = 0011 1101 print "2 - c 的值为：", c c = a ^ b; # 49 = 0011 0001 print "3 - c 的值为：", c c = ~a; # -61 = 1100 0011 print "4 - c 的值为：", c c = a << 2; # 240 = 1111 0000 print "5 - c 的值为：", c c = a >> 2; # 15 = 0000 1111 print "6 - c 的值为：", c
Примеры вышеуказанного вывода:
1 - c 的值为： 12 2 - c 的值为： 61 3 - c 的值为： 49 4 - c 的值为： -61 5 - c 的值为： 240 6 - c 的值为： 15
Модуль оператора Python
Модуль оператора Python обеспечивает набор функций, соответствующих операторам в Python. Эти имена функций такие же, как специальные методы, без двойных подчеркиваний.
Давайте посмотрим на пример пользовательского класса, который поддерживает операторы – +,> и *. Мы будем использовать функции модуля оператора для вызова этих методов на объектах класса.
import operator
class Data:
id = 0
def __init__(self, i):
self.id = i
def __add__(self, other):
return Data(self.id + other.id)
def __gt__(self, other):
return self.id > other.id
def __mul__(self, other):
return Data(self.id * other.id)
d1 = Data(10)
d2 = Data(20)
d3 = operator.add(d1, d2)
print(d3.id)
d3 = operator.mul(d1, d2)
print(d3.id)
flag = operator.gt(d1, d2)
print(flag)
Вложенные операторы If
Вложенные операторы if используются, когда нужно проверить второе условие, когда первое условие выполняется. Для этого можно использовать оператор if-else внутри другого оператора if-else. Синтаксис вложенного оператора if:
if statement1: #внешний оператор if
print("true")
if nested_statement: #вложенный оператор if
print("yes")
else: #вложенный оператор else
print("no")
else: #внешний оператор else
print("false")
Результатом работы программы может быть:
Если значение statement1 равно true, программа проверяет, равно ли true значение nested_statement. Если оба условия выполняются, результат будет следующим:
Вывод:
true yes
Если statement1оценивается как true, но nested_statement оценивается как false, вывод будет уже другим:
Вывод:trueno
Значение statement1 равно false, а вложенный оператор if-else не будет выполняться, поэтому «сработает» оператор else:
Вывод:
false
Также можно использовать несколько вложенных операторов if:
if statement1: #внешний if
print("hello world")
if nested_statement1: #первый вложенный if
print("yes")
elif nested_statement2: # первый вложенный elif
print("maybe")
else: # первый вложенный else
print("no")
elif statement2: # внешний elif
print("hello galaxy")
if nested_statement3: #второй вложенный if
print("yes")
elif nested_statement4: # второй вложенный elif
print("maybe")
else: # второй вложенный else
print("no")
else: # внешний else
statement("hello universe")
В приведенном выше коде внутри каждого оператора if (в дополнение к оператору elif ) используется вложенный if. Это дает больше вариантов в каждом условии.
Используем пример вложенных операторов if в программе grade.py. Сначала проверим, является ли балл проходным (больше или равно 65%). Затем оценим, какой буквенной оценке соответствует балл. Но если балл непроходной, нам не нужно проверять буквенные оценки. И можно сразу информировать ученика, что балл является непроходным. Модифицированный код с вложенным оператором if:
if grade >= 65:
print("Passing grade of:")
if grade >= 90:
print("A")
elif grade >=80:
print("B")
elif grade >=70:
print("C")
elif grade >= 65:
print("D")
else:
print("Failing grade")
При переменной grade равной 92 первое условие будет выполнено, и программа выведет «Passing grade of:». Затем она проверит, является ли оценка больше или равной 90. Это условие также будет выполнено и она выведет A.
Если переменная grade равна 60, то первое условие не будет выполнено. Поэтому программа пропустит вложенные операторы if, перейдет к оператору else и выведет сообщение «Failing grade».
Но можно добавить еще больше вариантов и использовать второй слой вложенных if. Например, чтобы определить оценки A+, A и A-. Мы можем сделать это, сначала проверив, является ли оценка проходной, затем, является ли оценка 90 или выше. А после этого, превышает ли оценка 96 для A+, например:
if grade >= 65:
print("Passing grade of:")
if grade >= 90:
if grade > 96:
print("A+")
elif grade > 93 and grade <= 96:
print("A")
elif grade >= 90:
print("A-")
Для переменной grade со значением 96 программа выполнит следующее:
- Проверит, является ли оценка больше или равной 65 (true).
- Выведет «Passing grade of:»
- Проверит, является ли оценка больше или равной 90 (true).
- Проверит, превышает ли оценка 96 (false).
- Проверит, является ли оценка больше 93, а также меньше или равна 96 (true).
- Выведет
- Пропустит оставшиеся вложенные условные операторы и вернется к остающемуся коду.
Результат работы программы для переменной grade равной 96:
Вывод:
Passing grade of: A
Вложенные операторы if позволяют добавлять несколько уровней условий в создаваемый код.
Библиотека math
Для проведения вычислений с действительными числами язык Python содержит много дополнительных функций, собранных в библиотеку, которая называется math. Для использования этих функций в начале программы необходимо подключить библиотеку, что делается командой
import math # подключение модуля библиотеки
После подключения программа получает доступ ко всем функциям, методам и классам, содержащимся в нём. После подключения можно вызвать любую функцию из подключенной библиотеки по следующему правилу: указывается имя модуля и через точку имя функции
имя_модуля.имя_функции
Например, пусть мы хотим вызвать функцию вычисления Синус угла, задаваемого в радианахimport math y = sin(5) # ошибка не подключен модуль mathx = math.sin(5) # записываем имя модуля и через точку имя функции
Можно подключать не весь модуль, а какую-то его часть. Например, программист хочет использовать только одну функцию из математической библиотеки math. Если он подключит всю библиотеку, то будет добавлено более 40 функций, которые будут занимать место. Чтобы добавить в проект какую-то часть, используют ключевое слово from
from <имя подключаемого модуля> import <название функции>
Например.
from math import sin # подключена только одна функция siny = sin(5) # операция выполненаx = cos(5) # ошибка функция cos не подключена
Ниже приведен список основных функций модуля math. Некоторые из перечисленных функций (int, round, abs) являются стандартными и не требуют подключения модуля math для использования.
Арифметические операторы
Арифметические операторы – синтаксические ярлыки для выполнения основных математических операций по номерам.
| Оператор | Имя | Описание | Пример |
| + | Добавление | Расчет суммы двух операндов | 3 + 4 |
| – | Вычитание | Вычитание второго операнда с первого операнда | 4 – 3 |
| * | Умножение | Умножить первый со вторым операндом | 3 * 4 |
| Разделение | Разделение первого на второй операнд | 3 / 4.75 | |
| % | Модуль | Расчет остатка при делите первого на второй операнд | 7 % 4 |
| // | Целочисленное разделение, напольное разделение | Разделение первого операнда на второй операнд и закругление результата до следующего целого числа | 8 // 3 |
| ** ** | Экспонент | Поднимая первый операнд на силу второго операнда | 2 ** 3 |
Операторы сравнения Python
Следующие допущения переменная а 10, Ь является переменной величиной 20:
операторы
описание
примеров
==
Равный — сравните объекты для равенства
(A == B) возвращает значение False.
! =
Это не равно — сравнить два объекта не равны
(A! = B) возвращает истину.
Это не равно — сравнить два объекта не равны
(A б) возвращает истину. Этот оператор подобен! =.
>
Больше — Возвращает ли х больше у
(A> B) возвращает значение False.
Обратите внимание, что эти переменные капитализации имя. (A
> =
Больше или равно — Возвращает ли х больше или равно у.
(A> = B) возвращает значение False.
Следующий пример иллюстрирует сравнение всех операций Python:
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 21 b = 10 c = 0 if ( a == b ): print "1 - a 等于 b" else: print "1 - a 不等于 b" if ( a != b ): print "2 - a 不等于 b" else: print "2 - a 等于 b" if ( a <> b ): print "3 - a 不等于 b" else: print "3 - a 等于 b" if ( a < b ): print "4 - a 小于 b" else: print "4 - a 大于等于 b" if ( a > b ): print "5 - a 大于 b" else: print "5 - a 小于等于 b" # 修改变量 a 和 b 的值 a = 5; b = 20; if ( a <= b ): print "6 - a 小于等于 b" else: print "6 - a 大于 b" if ( b >= a ): print "7 - b 大于等于 b" else: print "7 - b 小于 b"
Примеры вышеуказанного вывода:
1 - a 不等于 b 2 - a 不等于 b 3 - a 不等于 b 4 - a 大于等于 b 5 - a 大于 b 6 - a 小于等于 b 7 - b 大于等于 b
Циклы for
Циклы — любопытный пример. Когда вы пишете следующий код:
for x in sequence:
something(x)
он выполняется примерно так:
x = sequence something(x) x = sequence something(x) # и так далее...
На самом деле механизм получения значений из последовательности более сложен, чем простая индексация в примере. Но суть в том, что каждый элемент в последовательности присваивается имени в качестве значения, как если бы это делалось путем простого оператора присваивания. И, опять-таки, все правила, касающиеся присваиваний и их работы, применимы и к этому присваиванию.
Допустим, у нас есть список чисел. Мы хотим умножить каждое число на 10, чтобы из получить . Можно попытаться пойти простым путем, но нас ждет разочарование.
nums =
for x in nums: # x = nums ...
x = x * 10
print(nums) # :(
Давайте разберемся, почему так. При первой итерации — это еще одно имя для . Как мы разбирали ранее, если у вас есть два имени, ссылающиеся на одно значение, то при повторном присвоении значения одному из имен второе не меняется вместе с ним. В данном случае мы дали имени новое значение (), так что теперь ссылается на 10. Но по-прежнему ссылается на старое значение, 1.
Наш цикл не изменит исходный список, потому что мы просто раз за разом присваиваем новое значение для имени .
Лучшее, что можно посоветовать в такой ситуации, — это не изменять списки, а создавать новые:
Простые циклы
Давайте для начала рассмотрим в действии обычные циклы Python.
Используем чистый Python
Начнем с двух списков по тысяче элементов в каждом. Целочисленная переменная равна длине этих списков. Списки и получены путем случайного выбора из списка .
n = 1_000 x, y = random.sample(r, n), random.sample(r, n)
Давайте посмотрим, сколько времени потребуется для получения списка , элементов которого являются суммами соответствующих элементов списков и .
%%timeit
i, z = 0, []
while i < n:
z.append(x + y)
i += 1
В результате получим:
Заметим также, что результат выполнения команды зависит от многих факторов и может при каждом запуске быть разным.
Цикл должен быть лучше оптимизированным для подобных операций, так как был создан, чтобы перебирать коллекции, итераторы и генераторы. Давайте посмотрим, так ли это.
%%timeit
z = []
for i in range(n):
z.append(x + y)
Результатом будет:
В данном случае цикл не только работает быстрее, но и выглядит гораздо лучше, чем цикл .
Представления списков в языке Python очень похожи на обычные циклы и весьма удобны в простых ситуациях. Они имеют более компактный код и обычно чуть-чуть быстрее обычных циклов.
%%timeit z = + y for i in range(n)]
В результате получим:
Но пожалуйста, имейте ввиду, что представления списков не всегда применимы. В ряде более сложных задач вам придется использовать обычные циклы или .
Использование библиотеки NumPy
NumPy — это сторонняя библиотека, которая очень часто используется в численных вычислениях. Она особенно удобна для операций с массивами (для этого в ней есть множество полезных функций). Также она позволяет писать простой и элегантный код без использования циклов.
На самом деле циклы, равно как и другие критичные для производительности операции, реализованы в NumPy на системном уровне. Именно это и позволяет функциям NumPy быть быстрее обычных функций языка Python. Еще одним преимуществом является то, как Numpy обрабатывает переменные и типы.
Давайте для начала создадим из списков целого типа Python и массивы NumPy типа integer 64-bit (целочисленный 64-х битный тип числа).
x_, y_ = np.array(x, dtype=np.int64), np.array(y, dtype=np.int64)
Код для поэлементного сложения двух массивов так же прост, как и для сложения двух обычных переменных:. Но давайте проверим производительность:
%%timeit z = x_ + y_
Результат будет следующий:
Это почти в 85 раз быстрее, чем при использовании представления списков! И код крайне прост и красив. При работе с большими данными массивы NumPy — это самый лучший выбор. Причем, чем больше данных, тем больше выигрыш во времени.
И это не все. Если нам подходит 32-х битный целочисленный тип данных вместо 64-х битного, мы можем еще сэкономить не только память, но и время.
Точно так же теперь складываем два массива:
%%timeit z = x_ + y_
И результат будет следующий:
Результаты с большими ( и ) приведены в таблице в конце статьи. Они иллюстрируют ту же зависимость, причем выигрыш в производительности NumPy при росте тоже увеличивается.
Операторы членства
Оператор членства используется для идентификации членства в любой последовательности (списки, строки, кортежи).
и являются операторами членства.
Возвращает true, если указанное значение найден в последовательности. Возвращает false в противном случае.
Возвращает true, если указанное значение не найдено в последовательности. Возвращает false в противном случае.
a = #Is 3 in the list a? print 3 in a # prints True #Is 12 not in list a? print 12 not in a # prints True str = "Hello World" #Does the string str contain World? print "World" in str # prints True #Does the string str contain world? (note: case sensitive) print "world" in str # prints False print "code" not in str # prints True
Операторы Python приоритет
Если у вас есть несколько операторов в одном выражении, важно знать, какой оператор начнется первым. Например, рассмотрим выражение 2 * 3 + 4
Рассчитает ли Python (2 * 3) + 4 или 2 * (3 + 4)? В зависимости от оператора приоритет, результат будет 10 или 14.
В следующей таблице описаны отношения оператора приоритета. Самый верхний оператор имеет самый высокий приоритет.
| ЭКСПОРТЕНИЕ | ** ** |
| Побитовый нет | ~ |
| Умножение, разделение, модуло, целочисленное разделение | * / % // |
| Дополнение, вычитание | + – |
| Битона смена Право и лево | >> << >> << |
| Побил и | & |
| Побитовые хор и или | ^ | ^ | |
| Сравнение | <= < > >= |
| Равенство | <> == != <> == != |
| Назначения на месте | = %= /= //= -= += *= **= = %= /= //= -= += *= **= = %= /= //= -= += *= **= = %= /= //= -= += *= **= |
| Личность | это не |
| Членство | не вводится |
| Логично | не или и |
Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.
Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python одноклассники To help students reach higher levels of Python success, he founded the programming education website Finxter.com . He’s author of the popular programming book Python One-Liners (NoStarch 2020), coauthor of the Coffee Break Python series of self-published books, computer science enthusiast, freelancer
Его страсти пишут, чтение и кодирование. Но его величайшая страсть состоит в том, чтобы служить стремлению кодер через Finxter и помогать им повысить свои навыки. Вы можете присоединиться к его бесплатной академии электронной почты здесь.
